ObjectStateHandlerTest - Code Metrics - Inspection of "fixup! Fix EZP-26175: Exception instead of 404 whe..." - ezsystems/ezpublish-kernel - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — ezp26175-exception_on_non_defa... ( 77d2f3...ca5fc8 )

unknown
created 2016-10-31 11:49 UTC
ObjectStateHandlerTest A

↳ Parent: Project
Complexity

Total Complexity
Size/Duplication

Total Lines	1032
Duplicated Lines	18.8 %
Coupling/Cohesion

Components	1
Dependencies	6
Importance

Changes
Metric	Value
dl	194
loc	1032
rs	9.5721
c	0
b	0
f	0
wmc	30
lcom	1
cbo	6
24 Methods

Rating	Name	Duplication	Size	Complexity
B	testLoadGroupHasCache()	25	25	1
B	testLoadGroupByIdentifier()	0	28	1
A	generateObjectGroupsArray()	0	15	2
A	testLoadAllGroupsCached()	19	52	3
A	testLoadAllGroupsWithOffsetLimit()	0	4	1
A	testLoadAllGroupsCachedWithOffsetLimit()	0	4	1
A	testLoadObjectStatesCached()	19	72	2
B	testUpdateGroup()	0	37	1
B	testDeleteGroup()	0	32	1
B	testCreate()	0	38	1
B	testLoadCached()	26	26	1
B	testLoadByIdentifier()	0	29	1
B	testUpdate()	0	39	1
B	testSetPriority()	0	36	1
B	testDelete()	0	28	1
B	testSetContentState()	0	24	1
A	testGetContentStateCached()	0	49	1
B	testGetContentCount()	0	24	1
A	testCreateGroup()	0	56	1
A	testLoadGroup()	52	52	1
B	testLoadAllGroups()	0	82	3
B	testLoadObjectStates()	0	76	1
A	testLoad()	53	53	1
A	testGetContentState()	0	54	1
How to fix Duplicated Code

<?php

/**
 * File contains Test class.
 *
 * @copyright Copyright (C) eZ Systems AS. All rights reserved.
 * @license For full copyright and license information view LICENSE file distributed with this source code.
 *
 * @version //autogentag//
 */
namespace eZ\Publish\Core\Persistence\Cache\Tests;

use eZ\Publish\SPI\Persistence\Content\ObjectState as SPIObjectState;
use eZ\Publish\SPI\Persistence\Content\ObjectState\Group as SPIObjectStateGroup;
use eZ\Publish\SPI\Persistence\Content\ObjectState\InputStruct as SPIInputStruct;

/**
 * Test case for Persistence\Cache\ObjectStateHandler.
 */
class ObjectStateHandlerTest extends HandlerTest
{
    /**
     * @covers eZ\Publish\Core\Persistence\Cache\ObjectStateHandler::createGroup
     */
    public function testCreateGroup()
    {
        $inputStruct = new SPIInputStruct(
            array('identifier' => 'test_state_group', 'name' => 'Test State Group')
        );
        $expectedGroup = new SPIObjectStateGroup(
            array(
                'id' => 1,
                'identifier' => 'test_state_group',
                'name' => 'Test State Group',
            )
        );
        $this->loggerMock->expects($this->once())->method('logCall');

        $innerHandler = $this->getMock('eZ\\Publish\\SPI\\Persistence\\Content\\ObjectState\\Handler');
        $this->persistenceHandlerMock
            ->expects($this->once())
            ->method('objectStateHandler')
            ->will($this->returnValue($innerHandler));

        $innerHandler
            ->expects($this->once())
            ->method('createGroup')
            ->with($inputStruct)
            ->will(
                $this->returnValue($expectedGroup)
            );

        $this->cacheMock
            ->expects($this->once())
            ->method('clear')
            ->with('objectstategroup', 'all')
            ->will($this->returnValue(null));

        $cacheItemMock = $this->getMock('Stash\Interfaces\ItemInterface');
        $this->cacheMock
            ->expects($this->once())
            ->method('getItem')
            ->with('objectstategroup', 1)
            ->will($this->returnValue($cacheItemMock));

        $cacheItemMock
            ->expects($this->once())
            ->method('set')
            ->with($this->isInstanceOf('eZ\\Publish\\SPI\\Persistence\\Content\\ObjectState\\Group'))
            ->will($this->returnValue($cacheItemMock));

        $cacheItemMock
            ->expects($this->once())
            ->method('save')
            ->with();

        $handler = $this->persistenceCacheHandler->objectStateHandler();
        $group = $handler->createGroup($inputStruct);
        $this->assertEquals($group, $expectedGroup);
    }

    /**
     * @covers eZ\Publish\Core\Persistence\Cache\ObjectStateHandler::loadGroup
     */
    public function testLoadGroup()
    {
        $expectedGroup = new SPIObjectStateGroup(
            array(
                'id' => 1,
                'identifier' => 'test_state_group',
                'name' => 'Test State Group',
            )
        );

        $cacheItemMock = $this->getMock('Stash\Interfaces\ItemInterface');
        $this->cacheMock
            ->expects($this->once())
            ->method('getItem')
            ->with('objectstategroup', 1)
            ->will($this->returnValue($cacheItemMock));
        $cacheItemMock
            ->expects($this->once())
            ->method('get')
            ->will($this->returnValue(null));
        $cacheItemMock
            ->expects($this->once())
            ->method('isMiss')
            ->will($this->returnValue(true));
        $cacheItemMock
            ->expects($this->once())
            ->method('set')
            ->with($this->isInstanceOf('eZ\\Publish\\SPI\\Persistence\\Content\\ObjectState\\Group'))
            ->will($this->returnValue($cacheItemMock));
        $cacheItemMock
            ->expects($this->once())
            ->method('save')
            ->with();

        $this->loggerMock->expects($this->once())->method('logCall');

        $innerHandlerMock = $this->getMock('eZ\\Publish\\SPI\\Persistence\\Content\\ObjectState\\Handler');
        $this->persistenceHandlerMock
            ->expects($this->once())
            ->method('objectStateHandler')
            ->will($this->returnValue($innerHandlerMock));

        $innerHandlerMock
            ->expects($this->once())
            ->method('loadGroup')
            ->with(1)
            ->will($this->returnValue($expectedGroup));

        $handler = $this->persistenceCacheHandler->objectStateHandler();
        $group = $handler->loadGroup(1);
        $this->assertEquals($group, $expectedGroup);
    }

    /**
     * @covers eZ\Publish\Core\Persistence\Cache\ObjectStateHandler::loadGroup
     * @depends testLoadGroup
     */
    public function testLoadGroupHasCache()
    {
        $expectedGroup = new SPIObjectStateGroup(
            array(
                'id' => 1,
                'identifier' => 'test_state_group',
                'name' => 'Test State Group',
            )
        );

        $cacheItemMock = $this->getMock('Stash\Interfaces\ItemInterface');
        $this->cacheMock
            ->expects($this->once())
            ->method('getItem')
            ->with('objectstategroup', 1)
            ->will($this->returnValue($cacheItemMock));
        $cacheItemMock
            ->expects($this->once())
            ->method('get')
            ->will($this->returnValue($expectedGroup));

        $handler = $this->persistenceCacheHandler->objectStateHandler();
        $group = $handler->loadGroup(1);
        $this->assertEquals($group, $expectedGroup);
    }

    /**
     * @covers eZ\Publish\SPI\Persistence\Content\ObjectState\Handler::loadGroupByIdentifier
     */
    public function testLoadGroupByIdentifier()
    {
        $expectedGroup = new SPIObjectStateGroup(
            array(
                'id' => 1,
                'identifier' => 'test_state_group',
                'name' => 'Test State Group',
            )
        );

        $this->loggerMock->expects($this->once())->method('logCall');

        $innerHandlerMock = $this->getMock('eZ\\Publish\\SPI\\Persistence\\Content\\ObjectState\\Handler');
        $this->persistenceHandlerMock
            ->expects($this->once())
            ->method('objectStateHandler')
            ->will($this->returnValue($innerHandlerMock));

        $innerHandlerMock
            ->expects($this->once())
            ->method('loadGroupByIdentifier')
            ->with($expectedGroup->identifier)
            ->will($this->returnValue($expectedGroup));

        $group = $this->persistenceCacheHandler->objectStateHandler()
            ->loadGroupByIdentifier('test_state_group');
        $this->assertEquals($group, $expectedGroup);
    }

    public function generateObjectGroupsArray()
    {
        $result = array();
        for ($i = 1; $i <= 20; ++$i) {
            $result[] = new SPIObjectStateGroup(
                array(
                    'id' => $i,
                    'identifier' => "test_state_group_${i}",
                    'name' => "Test State Group #${i}",
                )
            );
        }

        return $result;
    }

    /**
     * @covers eZ\Publish\SPI\Persistence\Content\ObjectState\Handler::loadAllGroups
     */
    public function testLoadAllGroups($offset = 0, $limit = -1)
    {
        $testGroups = $this->generateObjectGroupsArray();
        $testGroupIds = array_map(
            function ($group) {
                return $group->id;
            },
            $testGroups
        );

        $cacheItemMock = $this->getMock('Stash\Interfaces\ItemInterface');
        $this->cacheMock
            ->expects($this->at(0))
            ->method('getItem')
            ->with('objectstategroup', 'all')
            ->will($this->returnValue($cacheItemMock));
        $cacheItemMock
            ->expects($this->once())
            ->method('get')
            ->will($this->returnValue(null));
        $cacheItemMock
            ->expects($this->once())
            ->method('isMiss')
            ->will($this->returnValue(true));

        $this->loggerMock->expects($this->once())->method('logCall');

        $innerHandlerMock = $this->getMock('eZ\\Publish\\SPI\\Persistence\\Content\\ObjectState\\Handler');
        $this->persistenceHandlerMock
            ->expects($this->once())
            ->method('objectStateHandler')
            ->will($this->returnValue($innerHandlerMock));

        $innerHandlerMock
            ->expects($this->once())
            ->method('loadAllGroups')
            ->with(0, -1)
            ->will($this->returnValue($testGroups));

        foreach ($testGroups as $group) {
            $this->cacheMock
                ->expects($this->at($group->id))
                ->method('getItem')
                ->with('objectstategroup', $group->id)
                ->will(
                    $this->returnCallback(
                        function ($cachekey, $i) use ($group) {

                            $cacheItemMock = $this->getMock('Stash\Interfaces\ItemInterface');
                            $cacheItemMock
                                ->expects($this->once())
                                ->method('set')
                                ->with($group)
                                ->will($this->returnValue($cacheItemMock));

                            $cacheItemMock
                                ->expects($this->once())
                                ->method('save')
                                ->with();

                            return $cacheItemMock;
                        }
                    )
                );
        }

        $cacheItemMock
            ->expects($this->once())
            ->method('set')
            ->with($testGroupIds)
            ->will($this->returnValue($cacheItemMock));

        $cacheItemMock
            ->expects($this->once())
            ->method('save')
            ->with();

        $handler = $this->persistenceCacheHandler->objectStateHandler();
        $groups = $handler->loadAllGroups($offset, $limit);

        $expectedGroups = array_slice($testGroups, $offset, $limit > -1 ?: null);
        $this->assertEquals($groups, $expectedGroups);
    }

    /**
     * @covers eZ\Publish\SPI\Persistence\Content\ObjectState\Handler::loadAllGroups
     */
    public function testLoadAllGroupsCached($offset = 0, $limit = -1)
    {
        $testGroups = $this->generateObjectGroupsArray($offset, $limit);
        $testGroupIds = array_map(
            function ($group) {
                return $group->id;
            },
            $testGroups
        );

        $cacheItemMock = $this->getMock('Stash\Interfaces\ItemInterface');
        $this->cacheMock
            ->expects($this->at(0))
            ->method('getItem')
            ->with('objectstategroup', 'all')
            ->will($this->returnValue($cacheItemMock));
        $cacheItemMock
            ->expects($this->once())
            ->method('get')
            ->will($this->returnValue($testGroupIds));
        $cacheItemMock
            ->expects($this->once())
            ->method('isMiss')
            ->will($this->returnValue(false));

        $expectedGroups = array_slice($testGroups, $offset, $limit > -1 ?: null);

        // loadGroup()
        foreach ($expectedGroups as $i => $group) {

            $this->cacheMock
                ->expects($this->at($i + 1))
                ->method('getItem')
                ->with('objectstategroup', $group->id)
                ->will(
                    $this->returnCallback(
                        function ($cachekey, $i) use ($group) {

                            $cacheItemMock = $this->getMock('Stash\Interfaces\ItemInterface');
                            $cacheItemMock
                                ->expects($this->once())
                                ->method('get')
                                ->will($this->returnValue($group));

                            return $cacheItemMock;
                        }
                    )
                );
        }

        $handler = $this->persistenceCacheHandler->objectStateHandler();
        $groups = $handler->loadAllGroups($offset, $limit);
        $this->assertEquals($groups, $expectedGroups);
    }

    /**
     * @covers eZ\Publish\SPI\Persistence\Content\ObjectState\Handler::loadAllGroups
     */
    public function testLoadAllGroupsWithOffsetLimit()
    {
        $this->testLoadAllGroups(7, 5);
    }

    /**
     * @covers eZ\Publish\SPI\Persistence\Content\ObjectState\Handler::loadAllGroups
     */
    public function testLoadAllGroupsCachedWithOffsetLimit()
    {
        $this->testLoadAllGroupsCached(7, 5);
    }

    /**
     * @covers eZ\Publish\SPI\Persistence\Content\ObjectState\Handler::loadObjectStates
     */
    public function testLoadObjectStates()
    {
        $testStates = array(
            new SPIObjectState(
                array(
                    'id' => 1,
                    'identifier' => 'test_state_1_group1',
                    'groupId' => 1,
                )
            ),
            new SPIObjectState(
                array(
                    'id' => 2,
                    'identifier' => 'test_state_2_group1',
                    'groupId' => 1,
                )
            ),
            new SPIObjectState(
                array(
                    'id' => 3,
                    'identifier' => 'test_state_3_group1',
                    'groupId' => 1,
                )
            ),
        );
        $testStateIds = array_map(
            function ($state) {
                return $state->id;
            },
            $testStates
        );

        $cacheItemMock = $this->getMock('Stash\Interfaces\ItemInterface');
        $this->cacheMock
            ->expects($this->at(0))
            ->method('getItem')
            ->with('objectstate', 'byGroup', 1)
            ->will($this->returnValue($cacheItemMock));
        $cacheItemMock
            ->expects($this->once())
            ->method('get')
            ->will($this->returnValue(null));
        $cacheItemMock
            ->expects($this->once())
            ->method('isMiss')
            ->will($this->returnValue(true));

        $this->loggerMock->expects($this->once())->method('logCall');

        $innerHandlerMock = $this->getMock('eZ\\Publish\\SPI\\Persistence\\Content\\ObjectState\\Handler');
        $this->persistenceHandlerMock
            ->expects($this->once())
            ->method('objectStateHandler')
            ->will($this->returnValue($innerHandlerMock));

        $innerHandlerMock
            ->expects($this->once())
            ->method('loadObjectStates')
            ->with(1)
            ->will($this->returnValue($testStates));

        $cacheItemMock
            ->expects($this->once())
            ->method('set')
            ->with($testStateIds)
            ->will($this->returnValue($cacheItemMock));

        $cacheItemMock
            ->expects($this->once())
            ->method('save')
            ->with();

        $handler = $this->persistenceCacheHandler->objectStateHandler();
        $states = $handler->loadObjectStates(1);
        $this->assertEquals($states, $testStates);
    }

    /**
     * @covers eZ\Publish\SPI\Persistence\Content\ObjectState\Handler::loadObjectStates
     */
    public function testLoadObjectStatesCached()
    {
        $testStates = array(
            new SPIObjectState(
                array(
                    'id' => 1,
                    'identifier' => 'test_state_1_group1',
                    'groupId' => 1,
                )
            ),
            new SPIObjectState(
                array(
                    'id' => 2,
                    'identifier' => 'test_state_2_group1',
                    'groupId' => 1,
                )
            ),
            new SPIObjectState(
                array(
                    'id' => 3,
                    'identifier' => 'test_state_3_group1',
                    'groupId' => 1,
                )
            ),
        );
        $testStateIds = array_map(
            function ($state) {
                return $state->id;
            },
            $testStates
        );

        $cacheItemMock = $this->getMock('Stash\Interfaces\ItemInterface');
        $this->cacheMock
            ->expects($this->at(0))
            ->method('getItem')
            ->with('objectstate', 'byGroup', 1)
            ->will($this->returnValue($cacheItemMock));
        $cacheItemMock
            ->expects($this->once())
            ->method('get')
            ->will($this->returnValue($testStateIds));
        $cacheItemMock
            ->expects($this->once())
            ->method('isMiss')
            ->will($this->returnValue(false));

        // load()
        foreach ($testStates as $i => $state) {

            $this->cacheMock
                ->expects($this->at($i + 1))
                ->method('getItem')
                ->with('objectstate', $state->id)
                ->will(
                    $this->returnCallback(
                        function ($cachekey, $i) use ($state) {

                            $cacheItemMock = $this->getMock('Stash\Interfaces\ItemInterface');
                            $cacheItemMock
                                ->expects($this->once())
                                ->method('get')
                                ->will($this->returnValue($state));

                            return $cacheItemMock;
                        }
                    )
                );
        }

        $handler = $this->persistenceCacheHandler->objectStateHandler();
        $states = $handler->loadObjectStates(1);
        $this->assertEquals($states, $testStates);
    }

    /**
     * @covers eZ\Publish\SPI\Persistence\Content\ObjectState\Handler::updateGroup
     */
    public function testUpdateGroup()
    {
        $inputStruct = new SPIInputStruct(
            array('identifier' => 'test_state_group', 'name' => 'Test State Group (New)')
        );
        $expectedGroup = new SPIObjectStateGroup(
            array(
                'id' => 1,
                'identifier' => 'test_state_group_new',
                'name' => 'Test State Group (New)',
            )
        );

        $this->loggerMock->expects($this->once())->method('logCall');

        $innerHandlerMock = $this->getMock('eZ\\Publish\\SPI\\Persistence\\Content\\ObjectState\\Handler');
        $this->persistenceHandlerMock
            ->expects($this->once())
            ->method('objectStateHandler')
            ->will($this->returnValue($innerHandlerMock));

        $innerHandlerMock
            ->expects($this->once())
            ->method('updateGroup')
            ->with(1, $inputStruct)
            ->will($this->returnValue($expectedGroup));

        $cacheItemMock = $this->getMock('Stash\Interfaces\ItemInterface');
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $this->cacheMock
            ->expects($this->at(0))
            ->method('clear')
            ->with('objectstategroup', 1);

        $handler = $this->persistenceCacheHandler->objectStateHandler();
        $newGroup = $handler->updateGroup(1, $inputStruct);
        $this->assertEquals($newGroup, $expectedGroup);
    }

    /**
     * @covers eZ\Publish\SPI\Persistence\Content\ObjectState\Handler::deleteGroup
     */
    public function testDeleteGroup()
    {
        $this->loggerMock->expects($this->once())->method('logCall');

        $innerHandlerMock = $this->getMock('eZ\\Publish\\SPI\\Persistence\\Content\\ObjectState\\Handler');
        $this->persistenceHandlerMock
            ->expects($this->once())
            ->method('objectStateHandler')
            ->will($this->returnValue($innerHandlerMock));

        $innerHandlerMock
            ->expects($this->once())
            ->method('deleteGroup')
            ->with(1);

        $cacheItemMock = $this->getMock('Stash\Interfaces\ItemInterface');
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $this->cacheMock
            ->expects($this->at(0))
            ->method('clear')
            ->with('objectstategroup', 'all');
        $this->cacheMock
            ->expects($this->at(1))
            ->method('clear')
            ->with('objectstategroup', 1);
        $this->cacheMock
            ->expects($this->at(2))
            ->method('clear')
            ->with('objectstate', 'byGroup', 1);

        $handler = $this->persistenceCacheHandler->objectStateHandler();
        $handler->deleteGroup(1);
    }

    /**
     * @covers eZ\Publish\SPI\Persistence\Content\ObjectState\Handler::create
     */
    public function testCreate()
    {
        $inputStruct = new SPIInputStruct(
            array('identifier' => 'test_state', 'name' => 'Test State')
        );
        $expectedState = new SPIObjectState(
            array(
                'id' => 1,
                'identifier' => 'test_state',
                'name' => 'Test State',
                'groupId' => 1,
            )
        );

        $this->loggerMock->expects($this->once())->method('logCall');

        $innerHandlerMock = $this->getMock('eZ\\Publish\\SPI\\Persistence\\Content\\ObjectState\\Handler');
        $this->persistenceHandlerMock
            ->expects($this->once())
            ->method('objectStateHandler')
            ->will($this->returnValue($innerHandlerMock));

        $innerHandlerMock
            ->expects($this->once())
            ->method('create')
            ->with(1, $inputStruct)
            ->will($this->returnValue($expectedState));

        $cacheItemMock = $this->getMock('Stash\Interfaces\ItemInterface');
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $this->cacheMock
            ->expects($this->at(0))
            ->method('clear')
            ->with('objectstate', 'byGroup', 1);

        $handler = $this->persistenceCacheHandler->objectStateHandler();
        $state = $handler->create(1, $inputStruct);
        $this->assertEquals($state, $expectedState);
    }

    /**
     * @covers \eZ\Publish\SPI\Persistence\Content\ObjectState\Handler::load
     */
    public function testLoad()
    {
        $expectedState = new SPIObjectState(
            array(
                'id' => 1,
                'identifier' => 'test_state',
                'name' => 'Test State',
                'groupId' => 1,
            )
        );

        $cacheItemMock = $this->getMock('Stash\Interfaces\ItemInterface');
        $this->cacheMock
            ->expects($this->once())
            ->method('getItem')
            ->with('objectstate', 1)
            ->will($this->returnValue($cacheItemMock));
        $cacheItemMock
            ->expects($this->once())
            ->method('get')
            ->will($this->returnValue(null));
        $cacheItemMock
            ->expects($this->once())
            ->method('isMiss')
            ->will($this->returnValue(true));
        $cacheItemMock
            ->expects($this->once())
            ->method('set')
            ->with($this->isInstanceOf('eZ\\Publish\\SPI\\Persistence\\Content\\ObjectState'))
            ->will($this->returnValue($cacheItemMock));
        $cacheItemMock
            ->expects($this->once())
            ->method('save')
            ->with();

        $this->loggerMock->expects($this->once())->method('logCall');

        $innerHandlerMock = $this->getMock('eZ\\Publish\\SPI\\Persistence\\Content\\ObjectState\\Handler');
        $this->persistenceHandlerMock
            ->expects($this->once())
            ->method('objectStateHandler')
            ->will($this->returnValue($innerHandlerMock));

        $innerHandlerMock
            ->expects($this->once())
            ->method('load')
            ->with(1)
            ->will($this->returnValue($expectedState));

        $handler = $this->persistenceCacheHandler->objectStateHandler();
        $state = $handler->load(1);
        $this->assertEquals($state, $expectedState);
    }

    /**
     * @covers \eZ\Publish\SPI\Persistence\Content\ObjectState\Handler::load
     * @depends testLoad
     */
    public function testLoadCached()
    {
        $expectedState = new SPIObjectState(
            array(
                'id' => 1,
                'identifier' => 'test_state',
                'name' => 'Test State',
                'groupId' => 1,
            )
        );

        $cacheItemMock = $this->getMock('Stash\Interfaces\ItemInterface');
        $this->cacheMock
            ->expects($this->once())
            ->method('getItem')
            ->with('objectstate', 1)
            ->will($this->returnValue($cacheItemMock));
        $cacheItemMock
            ->expects($this->once())
            ->method('get')
            ->will($this->returnValue($expectedState));

        $handler = $this->persistenceCacheHandler->objectStateHandler();
        $state = $handler->load(1);
        $this->assertEquals($state, $expectedState);
    }

    /**
     * @covers \eZ\Publish\SPI\Persistence\Content\ObjectState\Handler::loadByIdentifier
     */
    public function testLoadByIdentifier()
    {
        $expectedState = new SPIObjectState(
            array(
                'id' => 1,
                'identifier' => 'test_state',
                'name' => 'Test State',
                'groupId' => 1,
            )
        );

        $this->loggerMock->expects($this->once())->method('logCall');

        $innerHandlerMock = $this->getMock('eZ\\Publish\\SPI\\Persistence\\Content\\ObjectState\\Handler');
        $this->persistenceHandlerMock
            ->expects($this->once())
            ->method('objectStateHandler')
            ->will($this->returnValue($innerHandlerMock));

        $innerHandlerMock
            ->expects($this->once())
            ->method('loadByIdentifier')
            ->with($expectedState->identifier, $expectedState->groupId)
            ->will($this->returnValue($expectedState));

        $handler = $this->persistenceCacheHandler->objectStateHandler();
        $state = $handler->loadByIdentifier($expectedState->identifier, $expectedState->groupId);
        $this->assertEquals($state, $expectedState);
    }

    /**
     * @covers \eZ\Publish\SPI\Persistence\Content\ObjectState\Handler::update
     */
    public function testUpdate()
    {
        $inputStruct = new SPIInputStruct(
            array('identifier' => 'test_state_new', 'name' => 'Test State (new)')
        );

        $expectedState = new SPIObjectState(
            array(
                'id' => 1,
                'identifier' => 'test_state',
                'name' => 'Test State',
                'groupId' => 1,
            )
        );

        $this->loggerMock->expects($this->once())->method('logCall');

        $innerHandlerMock = $this->getMock('eZ\\Publish\\SPI\\Persistence\\Content\\ObjectState\\Handler');
        $this->persistenceHandlerMock
            ->expects($this->once())
            ->method('objectStateHandler')
            ->will($this->returnValue($innerHandlerMock));

        $innerHandlerMock
            ->expects($this->once())
            ->method('update')
            ->with($expectedState->id, $inputStruct)
            ->will($this->returnValue($expectedState));

        $cacheItemMock = $this->getMock('Stash\Interfaces\ItemInterface');
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $this->cacheMock
            ->expects($this->at(0))
            ->method('clear')
            ->with('objectstate', $expectedState->id);

        $handler = $this->persistenceCacheHandler->objectStateHandler();
        $state = $handler->update($expectedState->id, $inputStruct);
        $this->assertEquals($state, $expectedState);
    }

    /**
     * @covers \eZ\Publish\SPI\Persistence\Content\ObjectState\Handler::setPriority
     */
    public function testSetPriority()
    {
        $expectedState = new SPIObjectState(
            array(
                'id' => 1,
                'identifier' => 'test_state',
                'name' => 'Test State',
                'groupId' => 1,
                'priority' => 1,
            )
        );

        $this->loggerMock->expects($this->once())->method('logCall');

        $innerHandlerMock = $this->getMock('eZ\\Publish\\SPI\\Persistence\\Content\\ObjectState\\Handler');
        $this->persistenceHandlerMock
            ->expects($this->once())
            ->method('objectStateHandler')
            ->will($this->returnValue($innerHandlerMock));

        $innerHandlerMock
            ->expects($this->once())
            ->method('setPriority')
            ->with($expectedState->id, 1)
            ->will($this->returnValue($expectedState));

        $cacheItemMock = $this->getMock('Stash\Interfaces\ItemInterface');
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $this->cacheMock
            ->expects($this->at(0))
            ->method('clear')
            ->with('objectstate', $expectedState->id);

        $handler = $this->persistenceCacheHandler->objectStateHandler();
        $state = $handler->setPriority($expectedState->id, 1);
        $this->assertEquals($state, $expectedState);
    }

    /**
     * @covers \eZ\Publish\SPI\Persistence\Content\ObjectState\Handler::delete
     */
    public function testDelete()
    {
        $this->loggerMock->expects($this->once())->method('logCall');

        $innerHandlerMock = $this->getMock('eZ\\Publish\\SPI\\Persistence\\Content\\ObjectState\\Handler');
        $this->persistenceHandlerMock
            ->expects($this->once())
            ->method('objectStateHandler')
            ->will($this->returnValue($innerHandlerMock));

        $innerHandlerMock
            ->expects($this->once())
            ->method('delete')
            ->with(1);

        $cacheItemMock = $this->getMock('Stash\Interfaces\ItemInterface');
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $this->cacheMock
            ->expects($this->at(0))
            ->method('clear')
            ->with('objectstate', 1);
        $this->cacheMock
            ->expects($this->at(1))
            ->method('clear')
            ->with('objectstate', 'byGroup');

        $handler = $this->persistenceCacheHandler->objectStateHandler();
        $state = $handler->delete(1);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
    }

    /**
     * @covers \eZ\Publish\SPI\Persistence\Content\ObjectState\Handler::setContentState
     */
    public function testSetContentState()
    {
        $this->loggerMock->expects($this->once())->method('logCall');

        $innerHandlerMock = $this->getMock('eZ\\Publish\\SPI\\Persistence\\Content\\ObjectState\\Handler');
        $this->persistenceHandlerMock
            ->expects($this->once())
            ->method('objectStateHandler')
            ->will($this->returnValue($innerHandlerMock));

        $innerHandlerMock
            ->expects($this->once())
            ->method('setContentState')
            ->with(10, 1, 2);

        $cacheItemMock = $this->getMock('Stash\Interfaces\ItemInterface');
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $this->cacheMock
            ->expects($this->at(0))
            ->method('clear')
            ->with('objectstate', 'byContent', 10, 1);

        $handler = $this->persistenceCacheHandler->objectStateHandler();
        $state = $handler->setContentState(10, 1, 2);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
    }

    /**
     * @covers \eZ\Publish\SPI\Persistence\Content\ObjectState\Handler::getContentState
     */
    public function testGetContentState()
    {
        $expectedState = new SPIObjectState(
            array(
                'id' => 1,
                'identifier' => 'test_state',
                'name' => 'Test State',
                'groupId' => 1,
                'priority' => 1,
            )
        );

        $cacheItemMock = $this->getMock('Stash\Interfaces\ItemInterface');
        $this->cacheMock
            ->expects($this->at(0))
            ->method('getItem')
            ->with('objectstate', 'byContent', 10, 1)
            ->will($this->returnValue($cacheItemMock));
        $cacheItemMock
            ->expects($this->once())
            ->method('get')
            ->will($this->returnValue(null));
        $cacheItemMock
            ->expects($this->once())
            ->method('isMiss')
            ->will($this->returnValue(true));
        $cacheItemMock
            ->expects($this->once())
            ->method('set')
            ->with(1)
            ->will($this->returnValue($cacheItemMock));
        $cacheItemMock
            ->expects($this->once())
            ->method('save')
            ->with();

        $this->loggerMock->expects($this->once())->method('logCall');

        $innerHandlerMock = $this->getMock('eZ\\Publish\\SPI\\Persistence\\Content\\ObjectState\\Handler');
        $this->persistenceHandlerMock
            ->expects($this->once())
            ->method('objectStateHandler')
            ->will($this->returnValue($innerHandlerMock));

        $innerHandlerMock
            ->expects($this->once())
            ->method('getContentState')
            ->with(10, 1)
            ->will($this->returnValue($expectedState));

        $handler = $this->persistenceCacheHandler->objectStateHandler();
        $state = $handler->getContentState(10, 1, 2);
        $this->assertEquals($state, $expectedState);
    }

    /**
     * @covers \eZ\Publish\SPI\Persistence\Content\ObjectState\Handler::getContentState
     */
    public function testGetContentStateCached()
    {
        $expectedState = new SPIObjectState(
            array(
                'id' => 1,
                'identifier' => 'test_state',
                'name' => 'Test State',
                'groupId' => 1,
            )
        );

        $cacheItemMock = $this->getMock('Stash\Interfaces\ItemInterface');
        $this->cacheMock
            ->expects($this->at(0))
            ->method('getItem')
            ->with('objectstate', 'byContent', 10, 1)
            ->will($this->returnValue($cacheItemMock));
        $cacheItemMock
            ->expects($this->once())
            ->method('get')
            ->will($this->returnValue(1));
        $cacheItemMock
            ->expects($this->once())
            ->method('isMiss')
            ->will($this->returnValue(false));

        // load()
        $this->cacheMock
            ->expects($this->at(1))
            ->method('getItem')
            ->with('objectstate', $expectedState->id)
            ->will(
                $this->returnCallback(
                    function ($cachekey, $i) use ($expectedState) {

                        $cacheItemMock = $this->getMock('Stash\Interfaces\ItemInterface');
                        $cacheItemMock
                            ->expects($this->once())
                            ->method('get')
                            ->will($this->returnValue($expectedState));

                        return $cacheItemMock;
                    }
                )
            );

        $handler = $this->persistenceCacheHandler->objectStateHandler();
        $state = $handler->getContentState(10, 1);
        $this->assertEquals($state, $expectedState);
    }

    /**
     * @covers \eZ\Publish\SPI\Persistence\Content\ObjectState\Handler::getContentCount
     */
    public function testGetContentCount()
    {
        $expectedCount = 2;

        $this->loggerMock->expects($this->once())->method('logCall');

        $innerHandlerMock = $this->getMock('eZ\\Publish\\SPI\\Persistence\\Content\\ObjectState\\Handler');
        $this->persistenceHandlerMock
            ->expects($this->once())
            ->method('objectStateHandler')
            ->will($this->returnValue($innerHandlerMock));

        $innerHandlerMock
            ->expects($this->once())
            ->method('getContentCount')
            ->with(1)
            ->will($this->returnValue($expectedCount));

        //$this->logger->logCall( __METHOD__, array( 'stateId' => $stateId ) );

        $handler = $this->persistenceCacheHandler->objectStateHandler();
        $count = $handler->getContentCount(1);
        $this->assertEquals($count, $expectedCount);
    }
}

1			<?php
2
3			/**
4			* File contains Test class.
5			*
6			* @copyright Copyright (C) eZ Systems AS. All rights reserved.
7			* @license For full copyright and license information view LICENSE file distributed with this source code.
8			*
9			* @version //autogentag//
10			*/
11			namespace eZ\Publish\Core\Persistence\Cache\Tests;
12
13			use eZ\Publish\SPI\Persistence\Content\ObjectState as SPIObjectState;
14			use eZ\Publish\SPI\Persistence\Content\ObjectState\Group as SPIObjectStateGroup;
15			use eZ\Publish\SPI\Persistence\Content\ObjectState\InputStruct as SPIInputStruct;
16
17			/**
18			* Test case for Persistence\Cache\ObjectStateHandler.
19			*/
20			class ObjectStateHandlerTest extends HandlerTest
21			{
22			/**
23			* @covers eZ\Publish\Core\Persistence\Cache\ObjectStateHandler::createGroup
24			*/
25			public function testCreateGroup()
26			{
27			$inputStruct = new SPIInputStruct(
28			array('identifier' => 'test_state_group', 'name' => 'Test State Group')
29			);
30			$expectedGroup = new SPIObjectStateGroup(
31			array(
32			'id' => 1,
33			'identifier' => 'test_state_group',
34			'name' => 'Test State Group',
35			)
36			);
37			$this->loggerMock->expects($this->once())->method('logCall');
38
39			$innerHandler = $this->getMock('eZ\\Publish\\SPI\\Persistence\\Content\\ObjectState\\Handler');
40			$this->persistenceHandlerMock
ezsystems / ezpublish-kernel

Push — ezp26175-exception_on_non_defa... ( 77d2f3...ca5fc8 )

ObjectStateHandlerTest A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

24 Methods

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like
