MemoryWorkflowStoreTest - Code Metrics - old-town/old-town-workflow - Measure and Improve Code Quality continuously with Scrutinizer

MemoryWorkflowStoreTest D
last analyzed 2016-03-11 07:02 UTC

↳ Parent: Project
Complexity

Total Complexity
Size/Duplication

Total Lines	1047
Duplicated Lines	6.49 %
Coupling/Cohesion

Components	2
Dependencies	8
Importance

Changes	7
Bugs	0	Features	0
Metric	Value
wmc	44
c	7
b	0
f	0
lcom	2
cbo	8
dl	68
loc	1047
rs	4.6097
35 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	4	1
A	testInit()	0	6	1
A	testInitCorrect()	0	6	1
A	testGetPropertySetWithCachedEntry()	10	10	1
A	testGetPropertySetWithIncorrectEntryId()	0	5	1
A	testGetPropertySet()	0	18	1
A	testSetEntryState()	0	20	1
A	testFindNotIntEntry()	0	5	1
A	testFindNotExistsEntry()	0	5	1
A	testFindNotEntryInterfaceEntry()	0	8	1
A	testFindCorrectEntry()	10	10	1
A	testCreateEntry()	11	11	1
A	testCreateCurrentStep()	0	16	1
A	testFindCurrentStepWithIncorrectId()	0	5	1
A	testFindCurrectStep()	0	6	1
A	testMarkFinishedForEmptyCurrentSteps()	0	16	1
A	testMarkFinished()	0	57	1
B	testReset()	0	27	1
A	testMoveNotExistsInCurrentStepsStepToHistory()	0	15	1
A	testMoveToHistory()	0	64	1
A	testFindHistoryStepWithEmptyHistory()	0	7	1
A	testFindHistoryStep()	0	19	1
A	testQueryWithEmptyEntryCache()	0	9	1
A	testQueryEntryName()	0	69	1
A	testQueryEntryNameWithIncorrectOperator()	13	13	1
A	testEntryStateWithIncorrectValue()	12	12	1
A	testEntryState()	0	49	1
A	testEntryStateWithIncorrectOperator()	0	17	1
A	testEntryWithIncorrectField()	12	12	1
C	testQueryActionInCurrentSteps()	0	147	7
B	testQueryActionInHistorySteps()	0	103	4
A	testQueryStepsWithUnknownContext()	0	22	1
B	testSuccessNestedExpression()	0	31	1
B	testNestedExpressionWithoutResult()	0	41	1
A	testNestedExpressionWithIncorrectOperator()	0	22	1
How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.
Common duplication problems, and corresponding solutions are:
If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class
Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.
Complex classes like MemoryWorkflowStoreTest often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use MemoryWorkflowStoreTest, and based on these observations, apply Extract Interface, too.
<?php
/**
 * Created by PhpStorm.
 * User: keanor
 * Date: 26.10.15
 * Time: 20:28
 */
namespace OldTown\Workflow\PhpUnitTest\Spi\Memory;

use DateTime;
use OldTown\Workflow\Exception\InvalidArgumentException;
use OldTown\Workflow\Query\FieldExpression;
use OldTown\Workflow\Query\NestedExpression;
use OldTown\Workflow\Query\WorkflowExpressionQuery;
use OldTown\Workflow\Spi\Memory\MemoryWorkflowStore;
use OldTown\Workflow\Spi\SimpleStep;
use OldTown\Workflow\Spi\SimpleWorkflowEntry;
use OldTown\Workflow\Spi\StepInterface;
use OldTown\Workflow\Spi\WorkflowEntryInterface;
use PHPUnit_Framework_TestCase as TestCase;
use ReflectionProperty;
use SplObjectStorage;

/**
 * Class MemoryWorkflowStoreTest
 * @package OldTown\Workflow\PhpUnitTest\Spi\Memory
 */
class MemoryWorkflowStoreTest extends TestCase
{
    /**
     * Из-за того что методы статичные, при создании через new они не всегда пустые
     */
    protected function setUp()
    {
        MemoryWorkflowStore::reset();
    }

    /**
     * Поскольку init пустой то тестим только type hinting
     */
    public function testInit()
    {
        $memory = new MemoryWorkflowStore();
        $this->setExpectedException('PHPUnit_Framework_Error');
        $memory->init('this is not array');
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

    /**
     * Проверяем что init ничего не возвращает
     */
    public function testInitCorrect()
    {
        $memory = new MemoryWorkflowStore();
        $result = $memory->init([]);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();
        $this->assertNull($result);
    }

    /**
     * Тестируем корректное возвращение WorkflowEntryInterface из кэша
     */
    public function testGetPropertySetWithCachedEntry()

    {
        $memory = new MemoryWorkflowStore();
        $refStaticProp = new ReflectionProperty(MemoryWorkflowStore::class, 'propertySetCache');
        $refStaticProp->setAccessible(true);
        $entryMock = $this->getMockBuilder(WorkflowEntryInterface::class)->getMock();
        $refStaticProp->setValue([123 => $entryMock]);

        $this->assertEquals($entryMock, $memory->getPropertySet(123));
    }

    /**
     * Проверяем наличие exception при некорректном entryId
     *
     * @expectedException \OldTown\Workflow\Exception\ArgumentNotNumericException
     */
    public function testGetPropertySetWithIncorrectEntryId()
    {
        $memory = new MemoryWorkflowStore();
        $memory->getPropertySet('not int');
    }

    /**
     * Тестируем корректное получение и сохранение WorkflowEntryInterface в кэш
     */
    public function testGetPropertySet()
    {
        /** @var MemoryWorkflowStore|\PHPUnit_Framework_MockObject_MockObject $mockMemoryStore */
        $mockMemoryStore = $this->getMockBuilder(MemoryWorkflowStore::class)
            ->setMethods(['createPropertySet'])
            ->getMock();

        $entryMock = $this->getMockBuilder(WorkflowEntryInterface::class)->getMock();
        $mockMemoryStore->expects($this->once())
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->method('createPropertySet')
            ->will($this->returnValue($entryMock));

        $this->assertEquals($entryMock, $mockMemoryStore->getPropertySet(123));
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $refProperty = new ReflectionProperty(MemoryWorkflowStore::class, 'propertySetCache');
        $refProperty->setAccessible(true);
        $this->assertEquals([123 => $entryMock], $refProperty->getValue($mockMemoryStore));
    }

    /**
     * Проверяем что для сохраненного entry устанавливается статус
     *
     * findEntry мы тут не тестируем
     */
    public function testSetEntryState()
    {
        $entryMock = $this->getMockBuilder(SimpleWorkflowEntry::class)
            ->setMethods(['setState'])
            ->disableOriginalConstructor()
            ->getMock();

        $entryMock->expects($this->once())
            ->method('setState')
            ->with($this->equalTo(456));

        /** @var MemoryWorkflowStore|\PHPUnit_Framework_MockObject_MockObject $memoryMock */
        $memoryMock = $this->getMock(MemoryWorkflowStore::class, ['findEntry']);
        $memoryMock->expects($this->once())
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->method('findEntry')
            ->with($this->equalTo(123))
            ->will($this->returnValue($entryMock));

        $memoryMock->setEntryState(123, 456);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
    }

    /**
     * Поиск entry с некорректным id
     *
     * @expectedException \OldTown\Workflow\Exception\ArgumentNotNumericException
     */
    public function testFindNotIntEntry()
    {
        $memory = new MemoryWorkflowStore();
        $memory->findEntry('not int');
    }

    /**
     * Поиск несуществующего entry
     *
     * @expectedException \OldTown\Workflow\Exception\NotFoundWorkflowEntryException
     */
    public function testFindNotExistsEntry()
    {
        $memory = new MemoryWorkflowStore();
        $memory->findEntry(123);
    }

    /**
     * Проверка, что при некорректно сохраненном entry метод findEntry ругнется
     *
     * @expectedException \OldTown\Workflow\Exception\InvalidWorkflowEntryException
     */
    public function testFindNotEntryInterfaceEntry()
    {
        $memory = new MemoryWorkflowStore();
        $refProp = new \ReflectionProperty(MemoryWorkflowStore::class, 'entryCache');
        $refProp->setAccessible(true);
        $refProp->setValue($memory, [123 => 'asd']);
        $memory->findEntry(123);
    }

    /**
     * Проверяем что при корректно сохраненном entry метод findEntry его вернет
     */
    public function testFindCorrectEntry()

    {
        $memory = new MemoryWorkflowStore();
        $refProp = new ReflectionProperty(MemoryWorkflowStore::class, 'entryCache');
        $refProp->setAccessible(true);
        $entryMock = $this->getMockBuilder(WorkflowEntryInterface::class)->getMock();
        $refProp->setValue($memory, [123 => $entryMock]);

        $this->assertEquals($entryMock, $memory->findEntry(123));
    }

    /**
     * Тестируем создание + добавление в кэш
     */
    public function testCreateEntry()

    {
        $memory = new MemoryWorkflowStore();
        $entry = $memory->createEntry('wokflow_name');

        $this->assertInstanceOf(WorkflowEntryInterface::class, $entry);

        $refProp = new ReflectionProperty(MemoryWorkflowStore::class, 'entryCache');
        $refProp->setAccessible(true);
        $this->assertEquals([1 => $entry], $refProp->getValue($memory));
    }

    /**
     * Тестируем создание текущего шага
     */
    public function testCreateCurrentStep()
    {
        $memory = new MemoryWorkflowStore();
        $d = new DateTime();
        $step = $memory->createCurrentStep(123, 2, 'ow', $d, $d, 'stat', [1, 2, 3]);

        $refProp = new ReflectionProperty(MemoryWorkflowStore::class, 'currentStepsCache');
        $refProp->setAccessible(true);
        $stepsCache = $refProp->getValue($memory);

        $this->assertTrue(array_key_exists(123, $stepsCache));
        /** @var SplObjectStorage $objectStorage */
        $objectStorage = $stepsCache[123];
        $this->assertInstanceOf(SplObjectStorage::class, $objectStorage);
        $this->assertTrue($objectStorage->contains($step));
    }

    /**
     * Поиск текущего шага с некорректным id
     *
     * @expectedException \OldTown\Workflow\Exception\ArgumentNotNumericException
     */
    public function testFindCurrentStepWithIncorrectId()
    {
        $memory = new MemoryWorkflowStore();
        $memory->findCurrentSteps('asdasd');
    }

    /**
     * Тестируем создание пустого контейнера шага
     */
    public function testFindCurrectStep()
    {
        $memory = new MemoryWorkflowStore();
        $step = $memory->findCurrentSteps(123);
        $this->assertInstanceOf(SplObjectStorage::class, $step);
    }

    /**
     * Тестируем корректную работу метода при пустом currentSteps
     */
    public function testMarkFinishedForEmptyCurrentSteps()
    {
        $memory = new MemoryWorkflowStore();
        /** @var StepInterface|\PHPUnit_Framework_MockObject_MockObject $step */
        $step = $this->getMockBuilder(SimpleStep::class)
            ->setMethods(['getEntryId'])
            ->disableOriginalConstructor()
            ->getMock();

        $step->expects($this->once())
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->method('getEntryId')
            ->will($this->returnValue(123));

        $result = $memory->markFinished($step, 1, new DateTime(), 'done', 'petrov');
        $this->assertNull($result);
    }

    /**
     * Тестируем корректную работу
     */
    public function testMarkFinished()
    {
        // Данные для проверки
        $id = 2;
        $entryId = 123;
        $actionId = 1;
        $finishDate = new DateTime();
        $status = 'done';
        $caller = 'Petrov';

        $savedStep = $this->getMockBuilder(SimpleStep::class)
            ->setMethods(['getId', 'setStatus', 'setActionId', 'setFinishDate', 'setCaller'])
            ->disableOriginalConstructor()
            ->getMock();

        $savedStep->expects($this->once())
            ->method('getId')
            ->will($this->returnValue($id));
        $savedStep->expects($this->once())
            ->method('setStatus')
            ->with($this->equalTo($status));
        $savedStep->expects($this->once())
            ->method('setActionId')
            ->with($this->equalTo($actionId));
        $savedStep->expects($this->once())
            ->method('setFinishDate')
            ->with($this->equalTo($finishDate));
        $savedStep->expects($this->once())
            ->method('setCaller')
            ->with($this->equalTo($caller));

        $currentSteps = new SplObjectStorage();
        $currentSteps->attach($savedStep);

        /** @var MemoryWorkflowStore|\PHPUnit_Framework_MockObject_MockObject $storage */
        $storage = $this->getMockBuilder(MemoryWorkflowStore::class)
            ->setMethods(['findCurrentSteps'])
            ->getMock();
        $storage->expects($this->once())
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->method('findCurrentSteps')
            ->with($this->equalTo($entryId))
            ->will($this->returnValue($currentSteps));

        $step = $this->getMockBuilder(SimpleStep::class)
            ->setMethods(['getId', 'getEntryId'])
            ->disableOriginalConstructor()
            ->getMock();
        $step->expects($this->once())
            ->method('getEntryId')
            ->will($this->returnValue($entryId));
        $step->expects($this->once())
            ->method('getId')
            ->will($this->returnValue($id));

        $markedStep = $storage->markFinished($step, $actionId, $finishDate, $status, $caller);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        $this->assertEquals($savedStep, $markedStep);
    }

    /**
     * Проверяем что reset очищает все нужные св-ва
     */
    public function testReset()
    {
        $memory = new MemoryWorkflowStore();

        $refEntryProp = new ReflectionProperty(MemoryWorkflowStore::class, 'entryCache');
        $refEntryProp->setAccessible(true);
        $refEntryProp->setValue($memory, [123 => 'not empty array']);

        $refCurStepsProp = new ReflectionProperty(MemoryWorkflowStore::class, 'currentStepsCache');
        $refCurStepsProp->setAccessible(true);
        $refCurStepsProp->setValue($memory, [123 => 'not empty array']);

        $refHisStepsProp = new ReflectionProperty(MemoryWorkflowStore::class, 'historyStepsCache');
        $refHisStepsProp->setAccessible(true);
        $refHisStepsProp->setValue($memory, [123 => 'not empty array']);

        $refPropSetStepsProp = new ReflectionProperty(MemoryWorkflowStore::class, 'propertySetCache');
        $refPropSetStepsProp->setAccessible(true);
        $refPropSetStepsProp->setValue($memory, [123 => 'not empty array']);

        $memory->reset();

        $this->assertEquals($refEntryProp->getValue($memory), []);
        $this->assertEquals($refCurStepsProp->getValue($memory), []);
        $this->assertEquals($refHisStepsProp->getValue($memory), []);
        $this->assertEquals($refPropSetStepsProp->getValue($memory), []);
    }

    /**
     * Проверяем отсутствие ошибок при перемещении отсутствующего шага в историю
     */
    public function testMoveNotExistsInCurrentStepsStepToHistory()
    {
        // Мок для шага который будем перемещать в историю
        $step = $this->getMockBuilder(SimpleStep::class)
            ->disableOriginalConstructor()
            ->setMethods(['getEntryId', 'getId'])
            ->getMock();

        $step->expects($this->once())
            ->method('getEntryId')
            ->will($this->returnValue(123));

        $memory = new MemoryWorkflowStore();
        $memory->moveToHistory($step);
    }

    /**
     * Проверяем корректное перемещение шага в историю
     */
    public function testMoveToHistory()
    {
        // Мок который будет лежать в currentSteps
        $currentStep = $this->getMockBuilder(SimpleStep::class)
            ->disableOriginalConstructor()
            ->setMethods(['getId'])
            ->getMock();

        $currentStep->expects($this->once())
            ->method('getId')
            ->will($this->returnValue(2));

        $currentSteps = new SplObjectStorage();
        $currentSteps->attach($currentStep);

        // Мок который будет лежать в истории
        $historyStep = $this->getMockBuilder(SimpleStep::class)
            ->disableOriginalConstructor()
            ->setMethods(['getId'])
            ->getMock();

        $historyStep->expects($this->once())
            ->method('getId')
            ->will($this->returnValue(2));

        $historySteps = new SplObjectStorage();
        $historySteps->attach($historyStep);

        // Мок для шага который будем перемещать в историю
        $step = $this->getMockBuilder(SimpleStep::class)
            ->disableOriginalConstructor()
            ->setMethods(['getEntryId', 'getId'])
            ->getMock();

        $step->expects($this->once())
            ->method('getEntryId')
            ->will($this->returnValue(123));

        $step->expects($this->exactly(2))
            ->method('getId')
            ->will($this->returnValue(2));

        $memory = $this->getMockBuilder(MemoryWorkflowStore::class)
            ->setMethods(['findCurrentSteps'])
            ->getMock();

        $memory->expects($this->once())
            ->method('findCurrentSteps')
            ->with($this->equalTo(123))
            ->will($this->returnValue($currentSteps));

        $refHistory = new ReflectionProperty(MemoryWorkflowStore::class, 'historyStepsCache');
        $refHistory->setAccessible(true);
        $refHistory->setValue($memory, [123 => $historySteps]);

        $memory->moveToHistory($step);

        // Проверяем что шаг исчез из currentSteps
        $this->assertEquals($currentSteps->count(), 0);

        // Проверяем что шаг появился в historySteps
        $historyArray = $refHistory->getValue($memory);
        $this->assertTrue(array_key_exists(123, $historyArray));
    }

    /**
     * Проверяем что при отсутствии шага в истории, будет возвращен пустой SplObjectStorage
     */
    public function testFindHistoryStepWithEmptyHistory()
    {
        $memory = new MemoryWorkflowStore();
        $historySteps = $memory->findHistorySteps(123);
        $this->assertInstanceOf(SplObjectStorage::class, $historySteps);
        $this->assertEquals(0, $historySteps->count());
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
    }

    /**
     * Проверяем шаг из истории возвращается корректно
     */
    public function testFindHistoryStep()
    {
        // Мок который будет лежать в истории
        $historyStep = $this->getMockBuilder(SimpleStep::class)
            ->disableOriginalConstructor()
            ->getMock();

        $historySteps = new SplObjectStorage();
        $historySteps->attach($historyStep);

        $memory = new MemoryWorkflowStore();

        $refHistory = new ReflectionProperty(MemoryWorkflowStore::class, 'historyStepsCache');
        $refHistory->setAccessible(true);
        $refHistory->setValue($memory, [123 => $historySteps]);

        $stepsFromHistory = $memory->findHistorySteps(123);
        $this->assertEquals($historySteps, $stepsFromHistory);
    }

    /**
     * Проверяем query с пустым кэшем entry
     */
    public function testQueryWithEmptyEntryCache()
    {
        $query = new WorkflowExpressionQuery();
        $query->setExpression(new FieldExpression(1, 2, 3, 'value'));

        $memory = new MemoryWorkflowStore();
        $results = $memory->query($query);
        $this->assertEquals([], $results);
    }

    /**
     * Проверяем имя entry
     */
    public function testQueryEntryName()
    {
        $memory = new MemoryWorkflowStore();
        $memory->createEntry('entryName');

        // Проверяем равно, ожидаем правду
        $this->assertCount(1, $memory->query(new WorkflowExpressionQuery(new FieldExpression(
            FieldExpression::NAME,
            FieldExpression::ENTRY,
            FieldExpression::EQUALS,
            'entryName'
        ))));

        // Проверяем равно, ожидаем неправду
        $this->assertCount(0, $memory->query(new WorkflowExpressionQuery(new FieldExpression(
            FieldExpression::NAME,
            FieldExpression::ENTRY,
            FieldExpression::EQUALS,
            'incorrectName'
        ))));

        // Проверяем "не равно", ожидаем правду
        $this->assertCount(0, $memory->query(new WorkflowExpressionQuery(new FieldExpression(
            FieldExpression::NAME,
            FieldExpression::ENTRY,
            FieldExpression::NOT_EQUALS,
            'entryName'
        ))));

        // Проверяем "не равно", ожидаем неправду
        $this->assertCount(1, $memory->query(new WorkflowExpressionQuery(new FieldExpression(
            FieldExpression::NAME,
            FieldExpression::ENTRY,
            FieldExpression::NOT_EQUALS,
            'incorrectName'
        ))));

        // Проверяем "больше", ожидаем правду
        $this->assertCount(1, $memory->query(new WorkflowExpressionQuery(new FieldExpression(
            FieldExpression::NAME,
            FieldExpression::ENTRY,
            FieldExpression::GT,
            'enshrt'
        ))));

        // Проверяем "больше", ожидаем неправду
        $this->assertCount(0, $memory->query(new WorkflowExpressionQuery(new FieldExpression(
            FieldExpression::NAME,
            FieldExpression::ENTRY,
            FieldExpression::GT,
            'entryNameLooooooooong'
        ))));

        // Проверяем "Меньше", ожидаем правду
        $this->assertCount(1, $memory->query(new WorkflowExpressionQuery(new FieldExpression(
            FieldExpression::NAME,
            FieldExpression::ENTRY,
            FieldExpression::LT,
            'entryNameLooooooooong'
        ))));

        // Проверяем "Меньше", ожидаем неправду
        $this->assertCount(0, $memory->query(new WorkflowExpressionQuery(new FieldExpression(
            FieldExpression::NAME,
            FieldExpression::ENTRY,
            FieldExpression::LT,
            'enshrt'
        ))));
    }

    /**
     * Проверяем имя entry с некорректным условием
     *
     * @expectedException InvalidArgumentException
     */
    public function testQueryEntryNameWithIncorrectOperator()

    {
        $memory = new MemoryWorkflowStore();
        $memory->createEntry('entryName');

        // Проверяем "Меньше", ожидаем неправду
        $this->assertCount(0, $memory->query(new WorkflowExpressionQuery(new FieldExpression(
            FieldExpression::NAME,
            FieldExpression::ENTRY,
            123,
            'entryName'
        ))));
    }

    /**
     * Проверяем поиск экземпляра по состоянию
     *
     * @expectedException InvalidArgumentException
     */
    public function testEntryStateWithIncorrectValue()

    {
        $memory = new MemoryWorkflowStore();
        $memory->createEntry('entryName');

        $memory->query(new WorkflowExpressionQuery(new FieldExpression(
            FieldExpression::STATE,
            FieldExpression::ENTRY,
            FieldExpression::EQUALS,
            'not string'
        )));
    }

    /**
     * Тестируем поиск по состоянию
     */
    public function testEntryState()
    {
        $memory = new MemoryWorkflowStore();

        // Создаем entry с состоянием CREATED
        $created = $memory->createEntry('entry1');

        // Создаем второе entry и через рефлекию меняем его состояние
        $active = $memory->createEntry('entry2');
        $refPropState = new ReflectionProperty(SimpleWorkflowEntry::class, 'state');
        $refPropState->setAccessible(true);
        $refPropState->setValue($active, WorkflowEntryInterface::SUSPENDED);

        $results = $memory->query(new WorkflowExpressionQuery(new FieldExpression(
            FieldExpression::STATE,
            FieldExpression::ENTRY,
            FieldExpression::EQUALS,
            WorkflowEntryInterface::CREATED
        )));
        $this->assertArrayHasKey($created->getId(), $results);
        $this->assertArrayNotHasKey($active->getId(), $results);

        $results = $memory->query(new WorkflowExpressionQuery(new FieldExpression(
            FieldExpression::STATE,
            FieldExpression::ENTRY,
            FieldExpression::NOT_EQUALS,
            WorkflowEntryInterface::CREATED
        )));
        $this->assertArrayNotHasKey($created->getId(), $results);
        $this->assertArrayHasKey($active->getId(), $results);

        $results = $memory->query(new WorkflowExpressionQuery(new FieldExpression(
            FieldExpression::STATE,
            FieldExpression::ENTRY,
            FieldExpression::GT,
            WorkflowEntryInterface::SUSPENDED
        )));
        $this->assertArrayHasKey($created->getId(), $results);
        $this->assertArrayNotHasKey($active->getId(), $results);

        $results = $memory->query(new WorkflowExpressionQuery(new FieldExpression(
            FieldExpression::STATE,
            FieldExpression::ENTRY,
            FieldExpression::LT,
            WorkflowEntryInterface::CREATED
        )));
        $this->assertArrayNotHasKey($created->getId(), $results);
        $this->assertArrayHasKey($active->getId(), $results);
    }

    /**
     * @expectedException InvalidArgumentException
     */
    public function testEntryStateWithIncorrectOperator()
    {
        $memory = new MemoryWorkflowStore();
        $memory->createEntry('entry1');

        $expression = new FieldExpression(
            FieldExpression::STATE,
            FieldExpression::ENTRY,
            1,
            WorkflowEntryInterface::CREATED
        );
        $refProp = new ReflectionProperty(FieldExpression::class, 'operator');
        $refProp->setAccessible(true);
        $refProp->setValue($expression, 'not int operator');

        $memory->query(new WorkflowExpressionQuery($expression));
    }

    /**
     * @expectedException InvalidArgumentException
     */
    public function testEntryWithIncorrectField()

    {
        $memory = new MemoryWorkflowStore();
        $memory->createEntry('entry1');

        $memory->query(new WorkflowExpressionQuery(new FieldExpression(
            99999,
            FieldExpression::ENTRY,
            1,
            WorkflowEntryInterface::CREATED
        )));
    }

    /**
     * Тестируем наличие действия в текущем шаге
     */
    public function testQueryActionInCurrentSteps()
    {
        $memory = new MemoryWorkflowStore();
        $entry = $memory->createEntry('entryId');

        // Проверяем что не найдет
        $this->assertCount(0, $memory->query(new WorkflowExpressionQuery(new FieldExpression(
            FieldExpression::ACTION,
            FieldExpression::CURRENT_STEPS,
            FieldExpression::EQUALS,
            1
        ))));

        $step = $memory->createCurrentStep(
            $entry->getId(),
            1,
            'i am',
            new DateTime(),
            new DateTime('+1 h'),
            'status',
            []
        );

        try {
            $memory->query(new WorkflowExpressionQuery(new FieldExpression(
                FieldExpression::ACTION,
                FieldExpression::CURRENT_STEPS,
                FieldExpression::EQUALS,
                'incorrect value'
            )));
            $this->fail('expect InvalidArgumentException exception');
        } catch (InvalidArgumentException $e) {
            // nothing
        }

        $this->assertArrayHasKey($step->getId(), $memory->query(new WorkflowExpressionQuery(new FieldExpression(
            FieldExpression::ACTION,
            FieldExpression::CURRENT_STEPS,
            FieldExpression::EQUALS,
            $step->getActionId()
        ))));

        $this->assertArrayNotHasKey($step->getId(), $memory->query(new WorkflowExpressionQuery(new FieldExpression(
            FieldExpression::ACTION,
            FieldExpression::CURRENT_STEPS,
            FieldExpression::EQUALS,
            $step->getActionId(),
            true
        ))));

        $this->assertArrayHasKey($step->getId(), $memory->query(new WorkflowExpressionQuery(new FieldExpression(
            FieldExpression::OWNER,
            FieldExpression::CURRENT_STEPS,
            FieldExpression::EQUALS,
            $step->getOwner()
        ))));

        try {
            $memory->query(new WorkflowExpressionQuery(new FieldExpression(
                FieldExpression::OWNER,
                FieldExpression::CURRENT_STEPS,
                FieldExpression::EQUALS,
                function () {
                }// closure не стринг :)
            )));
            $this->fail('expect InvalidArgumentException exception on owner');
        } catch (InvalidArgumentException $e) {
            // nothing
        }

        $this->assertArrayHasKey($step->getId(), $memory->query(new WorkflowExpressionQuery(new FieldExpression(
            FieldExpression::START_DATE,
            FieldExpression::CURRENT_STEPS,
            FieldExpression::EQUALS,
            $step->getStartDate()
        ))));

        try {
            $memory->query(new WorkflowExpressionQuery(new FieldExpression(
                FieldExpression::START_DATE,
                FieldExpression::CURRENT_STEPS,
                FieldExpression::EQUALS,
                function () {
                }// closure не DateTime :)
            )));
            $this->fail('expect InvalidArgumentException exception on START_DATE');
        } catch (InvalidArgumentException $e) {
            // nothing
        }

        $this->assertArrayHasKey($step->getId(), $memory->query(new WorkflowExpressionQuery(new FieldExpression(
            FieldExpression::STATUS,
            FieldExpression::CURRENT_STEPS,
            FieldExpression::EQUALS,
            $step->getStatus()
        ))));

        try {
            $memory->query(new WorkflowExpressionQuery(new FieldExpression(
                FieldExpression::STATUS,
                FieldExpression::CURRENT_STEPS,
                FieldExpression::EQUALS,
                []
            )));
            $this->fail('expect InvalidArgumentException exception on STATUS');
        } catch (InvalidArgumentException $e) {
            // nothing
        }

        $this->assertArrayHasKey($step->getId(), $memory->query(new WorkflowExpressionQuery(new FieldExpression(
            FieldExpression::STEP,
            FieldExpression::CURRENT_STEPS,
            FieldExpression::EQUALS,
            $step->getStepId()
        ))));

        try {
            $memory->query(new WorkflowExpressionQuery(new FieldExpression(
                FieldExpression::STEP,
                FieldExpression::CURRENT_STEPS,
                FieldExpression::EQUALS,
                'asd'
            )));
            $this->fail('expect InvalidArgumentException exception on STEP');
        } catch (InvalidArgumentException $e) {
            // nothing
        }

        $this->assertArrayHasKey($step->getId(), $memory->query(new WorkflowExpressionQuery(new FieldExpression(
            FieldExpression::DUE_DATE,
            FieldExpression::CURRENT_STEPS,
            FieldExpression::EQUALS,
            $step->getDueDate()
        ))));

        try {
            $memory->query(new WorkflowExpressionQuery(new FieldExpression(
                FieldExpression::DUE_DATE,
                FieldExpression::CURRENT_STEPS,
                FieldExpression::EQUALS,
                'asd'
            )));
            $this->fail('expect InvalidArgumentException exception on DUE_DATE');
        } catch (InvalidArgumentException $e) {
            // nothing
        }
    }

    /**
     * Тестируем наличие действия в текущем шаге
     */
    public function testQueryActionInHistorySteps()
    {
        $memory = new MemoryWorkflowStore();
        $entry = $memory->createEntry('entryId');

        // Проверяем что не найдет
        $this->assertCount(0, $memory->query(new WorkflowExpressionQuery(new FieldExpression(
            FieldExpression::ACTION,
            FieldExpression::HISTORY_STEPS,
            FieldExpression::EQUALS,
            1
        ))));

        $step = $memory->createCurrentStep(
            $entry->getId(),
            1,
            'i am',
            new DateTime(),
            new DateTime('+1 h'),
            'status',
            []
        );

        $finishDate = new DateTime();
        $memory->markFinished($step, $step->getActionId(), $finishDate, 'f', 'ya');
        $memory->moveToHistory($step);

        $this->assertArrayHasKey($step->getId(), $memory->query(new WorkflowExpressionQuery(new FieldExpression(
            FieldExpression::FINISH_DATE,
            FieldExpression::HISTORY_STEPS,
            FieldExpression::EQUALS,
            $finishDate
        ))));

        try {
            $memory->query(new WorkflowExpressionQuery(new FieldExpression(
                FieldExpression::FINISH_DATE,
                FieldExpression::HISTORY_STEPS,
                FieldExpression::EQUALS,
                'asd'
            )));
            $this->fail('expect InvalidArgumentException exception on DUE_DATE');
        } catch (InvalidArgumentException $e) {
            // nothing
        }

        $this->assertArrayHasKey($step->getId(), $memory->query(new WorkflowExpressionQuery(new FieldExpression(
            FieldExpression::CALLER,
            FieldExpression::HISTORY_STEPS,
            FieldExpression::EQUALS,
            $step->getCaller()
        ))));

        try {
            $memory->query(new WorkflowExpressionQuery(new FieldExpression(
                FieldExpression::CALLER,
                FieldExpression::HISTORY_STEPS,
                FieldExpression::EQUALS,
                []
            )));
            $this->fail('expect InvalidArgumentException exception on DUE_DATE');
        } catch (InvalidArgumentException $e) {
            // nothing
        }

        // Заодно протестируем сравнение дат...
        $testDate = clone $finishDate;
        $this->assertArrayHasKey($step->getId(), $memory->query(new WorkflowExpressionQuery(new FieldExpression(
            FieldExpression::FINISH_DATE,
            FieldExpression::HISTORY_STEPS,
            FieldExpression::NOT_EQUALS,
            $testDate->modify('+1 hour')
        ))));

        $testDate = clone $finishDate;
        $this->assertArrayHasKey($step->getId(), $memory->query(new WorkflowExpressionQuery(new FieldExpression(
            FieldExpression::FINISH_DATE,
            FieldExpression::HISTORY_STEPS,
            FieldExpression::GT,
            $testDate->modify('-1 hour')
        ))));

        $testDate = clone $finishDate;
        $this->assertArrayHasKey($step->getId(), $memory->query(new WorkflowExpressionQuery(new FieldExpression(
            FieldExpression::FINISH_DATE,
            FieldExpression::HISTORY_STEPS,
            FieldExpression::LT,
            $testDate->modify('+1 hour')
        ))));

        try {
            $this->assertArrayHasKey($step->getId(), $memory->query(new WorkflowExpressionQuery(new FieldExpression(
                FieldExpression::FINISH_DATE,
                FieldExpression::HISTORY_STEPS,
                99999,
                $testDate
            ))));

            $this->fail('expect InvalidArgumentException exception FINISH_DATE');
        } catch (InvalidArgumentException $e) {
            // nothing
        }
    }

    /**
     * @expectedException \OldTown\Workflow\Exception\InvalidArgumentException
     */
    public function testQueryStepsWithUnknownContext()
    {
        $memory = new MemoryWorkflowStore();
        $entry = $memory->createEntry('entryId');

        $memory->createCurrentStep(
            $entry->getId(),
            1,
            'i am',
            new DateTime(),
            new DateTime('+1 h'),
            'status',
            []
        );

        $memory->query(new WorkflowExpressionQuery(new FieldExpression(
            FieldExpression::FINISH_DATE,
            999,
            FieldExpression::EQUALS,
            new DateTime()
        )));
    }

    /**
     * Тестируем вложенные выражения c AND и OR возвращающие результат
     */
    public function testSuccessNestedExpression()
    {
        $memory = new MemoryWorkflowStore();
        $memory->createEntry('entryName');

        $expression = new NestedExpression([
            new FieldExpression(
                FieldExpression::STATE,
                FieldExpression::ENTRY,
                FieldExpression::EQUALS,
                SimpleWorkflowEntry::CREATED
            ),
            new NestedExpression([
                new FieldExpression(
                    FieldExpression::NAME,
                    FieldExpression::ENTRY,
                    FieldExpression::EQUALS,
                    'somename'
                ),
                new FieldExpression(
                    FieldExpression::NAME,
                    FieldExpression::ENTRY,
                    FieldExpression::EQUALS,
                    'entryName'
                ),
            ], NestedExpression::OR_OPERATOR)
        ], NestedExpression::AND_OPERATOR);

        $result = $memory->query(new WorkflowExpressionQuery($expression));
        $this->assertCount(1, $result);
    }

    /**
     * Тестируем запросы в которых результат невозможен
     */
    public function testNestedExpressionWithoutResult()
    {
        $memory = new MemoryWorkflowStore();
        $memory->createEntry('entryName');

        $expression = new NestedExpression([
            new FieldExpression(
                FieldExpression::STATE,
                FieldExpression::ENTRY,
                FieldExpression::EQUALS,
                SimpleWorkflowEntry::CREATED
            ),
            new FieldExpression(
                FieldExpression::STATE,
                FieldExpression::ENTRY,
                FieldExpression::EQUALS,
                SimpleWorkflowEntry::ACTIVATED
            ),
        ], NestedExpression::AND_OPERATOR);

        $result = $memory->query(new WorkflowExpressionQuery($expression));
        $this->assertCount(0, $result);

        $expression = new NestedExpression([
            new FieldExpression(
                FieldExpression::STATE,
                FieldExpression::ENTRY,
                FieldExpression::EQUALS,
                SimpleWorkflowEntry::ACTIVATED
            ),
            new FieldExpression(
                FieldExpression::STATE,
                FieldExpression::ENTRY,
                FieldExpression::EQUALS,
                SimpleWorkflowEntry::ACTIVATED
            ),
        ], NestedExpression::OR_OPERATOR);

        $result = $memory->query(new WorkflowExpressionQuery($expression));
        $this->assertCount(0, $result);
    }

    /**
     * Тестируем наличие фатала
     *
     * @expectedException \OldTown\Workflow\Exception\InvalidArgumentException
     */
    public function testNestedExpressionWithIncorrectOperator()
    {
        $memory = new MemoryWorkflowStore();
        $memory->createEntry('entryName');

        $expression = new NestedExpression([
            new FieldExpression(
                FieldExpression::STATE,
                FieldExpression::ENTRY,
                FieldExpression::EQUALS,
                SimpleWorkflowEntry::CREATED
            ),
            new FieldExpression(
                FieldExpression::STATE,
                FieldExpression::ENTRY,
                FieldExpression::EQUALS,
                SimpleWorkflowEntry::ACTIVATED
            ),
        ], 999);

        $memory->query(new WorkflowExpressionQuery($expression));
    }
}

GitHub Access Token became invalid

MemoryWorkflowStoreTest D
last analyzed 2016-03-11 07:02 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Importance

35 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

old-town / old-town-workflow

GitHub Access Token became invalid

MemoryWorkflowStoreTest D last analyzed 2016-03-11 07:02 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Importance

35 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like

MemoryWorkflowStoreTest D
last analyzed 2016-03-11 07:02 UTC
