ScheduleSystemTasksCommandTest::testExecute() - Code Metrics - Inspection of "Implemented system-tasks (#38)" - php-task/TaskBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( a5a753...454108 )

by Wachter

created 2017-05-16 10:55 UTC

ScheduleSystemTasksCommandTest::testExecute() B

↳ Parent: ScheduleSystemTasksCommandTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	32
Code Lines	19

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	32
rs	8.8571
c	0
b	0
f	0
cc	1
eloc	19
nc	1
nop	0

<?php

namespace Task\TaskBundle\Unit\Command;

use Cron\CronExpression;
use Prophecy\Argument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Task\Execution\TaskExecutionInterface;
use Task\Scheduler\TaskSchedulerInterface;
use Task\Storage\TaskExecutionRepositoryInterface;
use Task\TaskBundle\Builder\TaskBuilder;
use Task\TaskBundle\Command\ScheduleSystemTasksCommand;
use Task\TaskBundle\Entity\Task;
use Task\TaskBundle\Entity\TaskRepository;
use Task\TaskBundle\Tests\Functional\TestHandler;
use Task\TaskStatus;

class ScheduleSystemTasksCommandTest extends \PHPUnit_Framework_TestCase
{
    /**
     * @var TaskSchedulerInterface
     */
    private $scheduler;

    /**
     * @var TaskRepository
     */
    private $taskRepository;

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

    protected function setUp()
    {
        $this->scheduler = $this->prophesize(TaskSchedulerInterface::class);

        $this->taskRepository = $this->prophesize(TaskRepository::class);

        $this->taskExecutionRepository = $this->prophesize(TaskExecutionRepositoryInterface::class);

    }

    /**
     * @param array $systemTasks
     *
     * @return ScheduleSystemTasksCommand
     */
    protected function createCommand(array $systemTasks)
    {
        return new ScheduleSystemTasksCommand(
            'task:schedule:system-tasks',
            $systemTasks,
            $this->scheduler->reveal(),

            $this->taskRepository->reveal(),
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            $this->taskExecutionRepository->reveal()

        );
    }

    public function testExecute()
    {
        $command = $this->createCommand(
            [
                'testing' => [
                    'enabled' => true,
                    'handler_class' => TestHandler::class,
                    'workload' => 'test',
                    'cron_expression' => '* * * * *',
                ],
            ]
        );

        $task = $this->prophesize(Task::class);
        $task->getSystemKey()->willReturn('testing');

        $taskBuilder = $this->prophesize(TaskBuilder::class);

        $this->taskRepository->findBySystemKey('testing')->willReturn(null);

        $this->taskRepository->findSystemTasks()->willReturn([$task->reveal()]);


        $this->scheduler->createTask(TestHandler::class, 'test')->shouldBeCalled()->willReturn($taskBuilder->reveal());


        $taskBuilder->setSystemKey('testing')->shouldBeCalled();
        $taskBuilder->cron('* * * * *')->shouldBeCalled();
        $taskBuilder->schedule()->shouldBeCalled();

        $command->run(
            $this->prophesize(InputInterface::class)->reveal(),
            $this->prophesize(OutputInterface::class)->reveal()
        );
    }

    public function testExecuteMultiple()
    {
        $command = $this->createCommand(
            [
                'testing-1' => [
                    'enabled' => true,
                    'handler_class' => TestHandler::class,
                    'workload' => 'test-1',
                    'cron_expression' => '* * * * *',
                ],
                'testing-2' => [
                    'enabled' => true,
                    'handler_class' => TestHandler::class,
                    'workload' => 'test-2',
                    'cron_expression' => '* * * * *',
                ],
            ]
        );

        $task1 = $this->prophesize(Task::class);
        $task1->getSystemKey()->willReturn('testing-1');
        $task2 = $this->prophesize(Task::class);
        $task2->getSystemKey()->willReturn('testing-2');

        $this->taskRepository->findBySystemKey('testing-1')->willReturn(null);

        $this->taskRepository->findBySystemKey('testing-2')->willReturn(null);

        $this->taskRepository->findSystemTasks()->willReturn([$task1->reveal(), $task2->reveal()]);


        $taskBuilder1 = $this->prophesize(TaskBuilder::class);
        $this->scheduler->createTask(TestHandler::class, 'test-1')->shouldBeCalled()->willReturn(

            $taskBuilder1->reveal()
        );
        $taskBuilder1->setSystemKey('testing-1')->shouldBeCalled();
        $taskBuilder1->cron('* * * * *')->shouldBeCalled();
        $taskBuilder1->schedule()->shouldBeCalled();

        $taskBuilder2 = $this->prophesize(TaskBuilder::class);
        $this->scheduler->createTask(TestHandler::class, 'test-2')->shouldBeCalled()->willReturn(

            $taskBuilder2->reveal()
        );
        $taskBuilder2->setSystemKey('testing-2')->shouldBeCalled();
        $taskBuilder2->cron('* * * * *')->shouldBeCalled();
        $taskBuilder2->schedule()->shouldBeCalled();

        $command->run(
            $this->prophesize(InputInterface::class)->reveal(),
            $this->prophesize(OutputInterface::class)->reveal()
        );
    }

    public function testExecuteDisable()
    {
        $command = $this->createCommand(
            [
                'testing' => [
                    'enabled' => false,
                    'handler_class' => TestHandler::class,
                    'workload' => 'test',
                    'cron_expression' => '* * * * *',
                ],
            ]
        );

        $task = $this->prophesize(Task::class);
        $task->getInterval()->willReturn(CronExpression::factory('* * * * *'));
        $task->getFirstExecution()->willReturn(new \DateTime());
        $task->getSystemKey()->willReturn('testing');

        $task->setInterval(
            $task->reveal()->getInterval(),
            $task->reveal()->getFirstExecution(),
            Argument::that(
                function ($date) {
                    return $date <= new \DateTime('+1 Minute');
                }
            )
        )->shouldBeCalled();

        $this->taskRepository->findBySystemKey('testing')->willReturn($task->reveal());

        $this->taskRepository->findSystemTasks()->willReturn([$task->reveal()]);


        $execution = $this->prophesize(TaskExecutionInterface::class);
        $execution->setStatus(TaskStatus::ABORTED);

        $this->taskExecutionRepository->findPending($task->reveal())->willReturn($execution->reveal());

        $this->taskExecutionRepository->save($execution->reveal())->shouldBeCalled();


        $command->run(
            $this->prophesize(InputInterface::class)->reveal(),
            $this->prophesize(OutputInterface::class)->reveal()
        );
    }

    public function testExecuteUpdate()
    {
        $command = $this->createCommand(
            [
                'testing' => [
                    'enabled' => true,
                    'handler_class' => TestHandler::class,
                    'workload' => 'test',
                    'cron_expression' => '* * * * *',
                ],
            ]
        );

        $task = $this->prophesize(Task::class);
        $task->getSystemKey()->willReturn('testing');
        $task->getHandlerClass()->willReturn(TestHandler::class);
        $task->getWorkload()->willReturn('test');
        $task->getInterval()->willReturn(CronExpression::factory('@daily'));
        $task->getFirstExecution()->willReturn(new \DateTime());

        $task->setInterval(CronExpression::factory('* * * * *'), $task->reveal()->getFirstExecution())->shouldBeCalled(
            );

        $this->taskRepository->findBySystemKey('testing')->willReturn($task->reveal());

        $this->taskRepository->findSystemTasks()->willReturn([$task->reveal()]);


        $execution = $this->prophesize(TaskExecutionInterface::class);
        $execution->setStatus(TaskStatus::ABORTED);

        $this->taskExecutionRepository->findPending($task->reveal())->willReturn($execution->reveal());

        $this->taskExecutionRepository->save($execution->reveal())->shouldBeCalled();


        $this->scheduler->scheduleTasks()->shouldBeCalled();

        $command->run(
            $this->prophesize(InputInterface::class)->reveal(),
            $this->prophesize(OutputInterface::class)->reveal()
        );
    }

    public function testExecuteUpdateNotSupported()
    {
        $command = $this->createCommand(
            [
                'testing' => [
                    'enabled' => true,
                    'handler_class' => TestHandler::class,
                    'workload' => 'test',
                    'cron_expression' => '* * * * *',
                ],
            ]
        );

        $task = $this->prophesize(Task::class);
        $task->getSystemKey()->willReturn('testing');
        $task->getHandlerClass()->willReturn('not-existing');
        $task->getWorkload()->willReturn('new-workload');
        $task->getInterval()->willReturn(CronExpression::factory('@daily'));
        $task->getFirstExecution()->willReturn(new \DateTime());

        $task->setInterval(Argument::cetera())->shouldNotBeCalled();

        $this->taskRepository->findBySystemKey('testing')->willReturn($task->reveal());

        $this->taskRepository->findSystemTasks()->willReturn([$task->reveal()]);


        $this->taskExecutionRepository->save(Argument::cetera())->shouldNotBeCalled();
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $this->scheduler->scheduleTasks()->shouldNotBeCalled();

        $command->run(
            $this->prophesize(InputInterface::class)->reveal(),
            $this->prophesize(OutputInterface::class)->reveal()
        );
    }

    public function testExecuteRemove()
    {
        $command = $this->createCommand([]);

        $task = $this->prophesize(Task::class);
        $task->getInterval()->willReturn(CronExpression::factory('* * * * *'));
        $task->getFirstExecution()->willReturn(new \DateTime());
        $task->getSystemKey()->willReturn('testing');

        $task->setInterval(
            $task->reveal()->getInterval(),
            $task->reveal()->getFirstExecution(),
            Argument::that(
                function ($date) {
                    return $date <= new \DateTime('+1 Minute');
                }
            )
        )->shouldBeCalled();

        $this->taskRepository->findBySystemKey('testing')->willReturn($task->reveal());

        $this->taskRepository->findSystemTasks()->willReturn([$task->reveal()]);


        $execution = $this->prophesize(TaskExecutionInterface::class);
        $execution->setStatus(TaskStatus::ABORTED);

        $this->taskExecutionRepository->findPending($task->reveal())->willReturn($execution->reveal());

        $this->taskExecutionRepository->save($execution->reveal())->shouldBeCalled();


        $command->run(
            $this->prophesize(InputInterface::class)->reveal(),
            $this->prophesize(OutputInterface::class)->reveal()
        );
    }
}


1			<?php
2
3			namespace Task\TaskBundle\Unit\Command;
4
5			use Cron\CronExpression;
6			use Prophecy\Argument;
7			use Symfony\Component\Console\Input\InputInterface;
8			use Symfony\Component\Console\Output\OutputInterface;
9			use Task\Execution\TaskExecutionInterface;
10			use Task\Scheduler\TaskSchedulerInterface;
11			use Task\Storage\TaskExecutionRepositoryInterface;
12			use Task\TaskBundle\Builder\TaskBuilder;
13			use Task\TaskBundle\Command\ScheduleSystemTasksCommand;
14			use Task\TaskBundle\Entity\Task;
15			use Task\TaskBundle\Entity\TaskRepository;
16			use Task\TaskBundle\Tests\Functional\TestHandler;
17			use Task\TaskStatus;
18
19			class ScheduleSystemTasksCommandTest extends \PHPUnit_Framework_TestCase
20			{
21			/**
22			* @var TaskSchedulerInterface
23			*/
24			private $scheduler;
25
26			/**
27			* @var TaskRepository
28			*/
29			private $taskRepository;
30
31			/**
32			* @var TaskExecutionRepositoryInterface
33			*/
34			private $taskExecutionRepository;
35
36			protected function setUp()
37			{
38			$this->scheduler = $this->prophesize(TaskSchedulerInterface::class);
			0 ignored issues – show Documentation Bug introduced 2017-05-16 11:02 UTC by Report Bug Copy Issue Report It seems like `$this->prophesize(\Task\...edulerInterface::class)` of type `object<Prophecy\Prophecy\ObjectProphecy>` is incompatible with the declared type `object<Task\Scheduler\TaskSchedulerInterface>` of property `$scheduler`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
39			$this->taskRepository = $this->prophesize(TaskRepository::class);

php-task / TaskBundle

Push — master ( a5a753...454108 )

ScheduleSystemTasksCommandTest::testExecute() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like