Task\TaskBundle\Tests\Functional\BaseCommandTestCase

Complexity

Total Complexity

4

Size/Duplication

Total Lines	102
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	17	1
A	createTask()	0	11	2
A	createTaskExecution()	0	9	1
	getCommand()	0	1	?

<?php

/*
 * This file is part of php-task library.
 *
 * (c) php-task
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

namespace Task\TaskBundle\Tests\Functional;

use Cron\CronExpression;
use Symfony\Bundle\FrameworkBundle\Console\Application;
use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Tester\CommandTester;
use Task\Execution\TaskExecutionInterface;
use Task\Runner\TaskRunnerInterface;
use Task\Scheduler\TaskSchedulerInterface;
use Task\Storage\TaskExecutionRepositoryInterface;
use Task\Storage\TaskRepositoryInterface;
use Task\TaskInterface;
use Task\TaskStatus;

/**
 * Base class for testing commands.
 */
abstract class BaseCommandTestCase extends KernelTestCase
{
    /**
     * @var Application
     */
    protected $application;

    /**
     * @var TaskRepositoryInterface
     */
    protected $taskRepository;

    /**
     * @var TaskExecutionRepositoryInterface
     */
    protected $taskExecutionRepository;

    /**
     * @var TaskSchedulerInterface
     */
    protected $taskScheduler;

    /**
     * @var TaskRunnerInterface
     */
    protected $taskRunner;

    /**
     * @var Command
     */
    protected $command;

    /**
     * @var CommandTester
     */
    protected $commandTester;

    public function setUp()
    {
        self::bootKernel();

        $this->taskRunner = self::$kernel->getContainer()->get('task.runner');
        $this->taskScheduler = self::$kernel->getContainer()->get('task.scheduler');
        $this->taskRepository = self::$kernel->getContainer()->get('task.storage.task');
        $this->taskExecutionRepository = self::$kernel->getContainer()->get('task.storage.task_execution');

        $command = $this->getCommand();

        $this->application = new Application(self::$kernel);
        $this->application->add($command);

        $this->command = $this->application->find($command->getName());
        $this->commandTester = new CommandTester($this->command);
    }

    /**
     * Create new task.
     *
     * @param string $workload
     * @param CronExpression $cronExpression
     * @param string $handlerClass
     *
     * @return TaskInterface
     */
    protected function createTask($workload, CronExpression $cronExpression = null, $handlerClass = TestHandler::class)
    {
        $task = $this->taskRepository->create($handlerClass, $workload);
        if ($cronExpression) {
            $task->setInterval($cronExpression, new \DateTime(), new \DateTime('+1 year'));
        }
        $this->taskRepository->persist($task);
        $this->taskRepository->flush();

        return $task;
    }

    /**
     * Create task-execution.
     *
     * @param TaskInterface $task
     * @param \DateTime $scheduleTime
     * @param string $status
     *
     * @return TaskExecutionInterface
     */
    protected function createTaskExecution(TaskInterface $task, \DateTime $scheduleTime, $status = TaskStatus::PLANNED)
    {
        $execution = $this->taskExecutionRepository->create($task, $scheduleTime);
        $execution->setStatus($status);
        $this->taskExecutionRepository->persist($execution);
        $this->taskExecutionRepository->flush();

        return $execution;
    }

    /**
     * Returns command.
     *
     * @return Command
     */
    protected abstract function getCommand();

The abstract declaration must precede the visibility declaration

}