9.5/_repository_test_8php_source.html

<?php

declare(strict_types = 1);

namespace ‪TYPO3\CMS\Extbase\Tests\Unit\Persistence;


/*

 * This file is part of the TYPO3 CMS project.

 *

 * It is free software; you can redistribute it and/or modify it under

 * the terms of the GNU General Public License, either version 2

 * of the License, or any later version.

 *

 * For the full copyright and license information, please read the

 * LICENSE.txt file that was distributed with this source code.

 *

 * The TYPO3 project - inspiring people to share!

 */


use ‪TYPO3\CMS\Extbase\Persistence\Exception\IllegalObjectTypeException;

use ‪TYPO3\CMS\Extbase\Persistence\Generic\Backend;

use ‪TYPO3\CMS\Extbase\Persistence\Generic\Exception\UnsupportedMethodException;

use TYPO3\TestingFramework\Core\Unit\UnitTestCase;


class ‪RepositoryTest extends UnitTestCase

{

    protected ‪$repository;


    protected ‪$mockObjectManager;


    protected ‪$mockQueryFactory;


    protected ‪$mockBackend;


    protected ‪$mockSession;


    protected ‪$mockPersistenceManager;


    protected ‪$mockQuery;


    protected ‪$mockQuerySettings;


    protected ‪$mockConfigurationManager;


    protected function ‪setUp()

    {

        $this->mockQueryFactory = $this->createMock(\‪TYPO3\CMS\‪Extbase\Persistence\Generic\QueryFactory::class);

        $this->mockQuery = $this->createMock(\‪TYPO3\CMS\‪Extbase\Persistence\QueryInterface::class);

        $this->mockQuerySettings = $this->createMock(\‪TYPO3\CMS\‪Extbase\Persistence\Generic\QuerySettingsInterface::class);

        $this->mockQuery->expects($this->any())->method('getQuerySettings')->will($this->returnValue($this->mockQuerySettings));

        $this->mockQueryFactory->expects($this->any())->method('create')->will($this->returnValue($this->mockQuery));

        $this->mockSession = $this->createMock(\‪TYPO3\CMS\‪Extbase\Persistence\Generic\Session::class);

        $this->mockConfigurationManager = $this->createMock(\‪TYPO3\CMS\‪Extbase\Configuration\ConfigurationManager::class);

        $this->mockBackend = $this->getAccessibleMock(Backend::class, ['dummy'], [$this->mockConfigurationManager], '', false);

        $this->inject($this->mockBackend, 'session', $this->mockSession);

        $this->mockPersistenceManager = $this->getAccessibleMock(\‪TYPO3\CMS\‪Extbase\Persistence\Generic\PersistenceManager::class, ['createQueryForType']);

        $this->inject($this->mockBackend, 'persistenceManager', $this->mockPersistenceManager);

        $this->inject($this->mockPersistenceManager, 'persistenceSession', $this->mockSession);

        $this->inject($this->mockPersistenceManager, 'backend', $this->mockBackend);

        $this->mockPersistenceManager->expects($this->any())->method('createQueryForType')->will($this->returnValue($this->mockQuery));

        $this->mockObjectManager = $this->createMock(\‪TYPO3\CMS\‪Extbase\Object\ObjectManagerInterface::class);

        $this->repository = $this->getAccessibleMock(\‪TYPO3\CMS\‪Extbase\Persistence\Repository::class, ['dummy'], [$this->mockObjectManager]);

        $this->repository->_set('persistenceManager', $this->mockPersistenceManager);

    }


    public function ‪abstractRepositoryImplementsRepositoryInterface()

    {

        $this->assertTrue($this->repository instanceof \‪TYPO3\CMS\‪Extbase\Persistence\RepositoryInterface);

    }


    public function ‪createQueryCallsPersistenceManagerWithExpectedClassName()

    {

        ‪$mockPersistenceManager = $this->createMock(\‪TYPO3\CMS\‪Extbase\Persistence\Generic\PersistenceManager::class);

        ‪$mockPersistenceManager->expects($this->once())->method('createQueryForType')->with('ExpectedType');


        $this->repository->_set('objectType', 'ExpectedType');

        $this->inject($this->repository, 'persistenceManager', ‪$mockPersistenceManager);


        $this->repository->createQuery();

    }


    public function ‪createQuerySetsDefaultOrderingIfDefined()

    {

        $orderings = ['foo' => ‪\TYPO3\CMS\Extbase\Persistence\QueryInterface::ORDER_ASCENDING];

        ‪$mockQuery = $this->createMock(\‪TYPO3\CMS\‪Extbase\Persistence\QueryInterface::class);

        ‪$mockQuery->expects($this->once())->method('setOrderings')->with($orderings);

        ‪$mockPersistenceManager = $this->createMock(\‪TYPO3\CMS\‪Extbase\Persistence\Generic\PersistenceManager::class);

        ‪$mockPersistenceManager->expects($this->exactly(2))->method('createQueryForType')->with('ExpectedType')->will($this->returnValue(‪$mockQuery));


        $this->repository->_set('objectType', 'ExpectedType');

        $this->inject($this->repository, 'persistenceManager', ‪$mockPersistenceManager);

        $this->repository->setDefaultOrderings($orderings);

        $this->repository->createQuery();


        $this->repository->setDefaultOrderings([]);

        $this->repository->createQuery();

    }


    public function ‪findAllCreatesQueryAndReturnsResultOfExecuteCall()

    {

        $expectedResult = $this->createMock(\‪TYPO3\CMS\‪Extbase\Persistence\QueryResultInterface::class);


        ‪$mockQuery = $this->createMock(\‪TYPO3\CMS\‪Extbase\Persistence\QueryInterface::class);

        ‪$mockQuery->expects($this->once())->method('execute')->with()->will($this->returnValue($expectedResult));


        ‪$repository = $this->getMockBuilder(\‪TYPO3\CMS\‪Extbase\Persistence\Repository::class)

            ->setMethods(['createQuery'])

            ->setConstructorArgs([$this->mockObjectManager])

            ->getMock();

        ‪$repository->expects($this->once())->method('createQuery')->will($this->returnValue(‪$mockQuery));


        $this->assertSame($expectedResult, ‪$repository->findAll());

    }


    public function ‪findByidentifierReturnsResultOfGetObjectByIdentifierCallFromBackend()

    {

        $identifier = '42';

        $object = new \stdClass();


        $expectedResult = $this->createMock(\‪TYPO3\CMS\‪Extbase\Persistence\QueryResultInterface::class);

        $expectedResult->expects($this->once())->method('getFirst')->will($this->returnValue($object));


        $this->mockQuery->expects($this->any())->method('getQuerySettings')->will($this->returnValue($this->mockQuerySettings));

        $this->mockQuery->expects($this->once())->method('matching')->will($this->returnValue($this->mockQuery));

        $this->mockQuery->expects($this->once())->method('execute')->will($this->returnValue($expectedResult));


        // skip backend, as we want to test the backend

        $this->mockSession->expects($this->any())->method('hasIdentifier')->will($this->returnValue(false));

        $this->assertSame($object, $this->repository->findByIdentifier($identifier));

    }


    public function ‪addDelegatesToPersistenceManager()

    {

        $object = new \stdClass();

        ‪$mockPersistenceManager = $this->createMock(\‪TYPO3\CMS\‪Extbase\Persistence\PersistenceManagerInterface::class);

        ‪$mockPersistenceManager->expects($this->once())->method('add')->with($object);

        $this->inject($this->repository, 'persistenceManager', ‪$mockPersistenceManager);

        $this->repository->_set('objectType', get_class($object));

        $this->repository->add($object);

    }


    public function ‪removeDelegatesToPersistenceManager()

    {

        $object = new \stdClass();

        ‪$mockPersistenceManager = $this->createMock(\‪TYPO3\CMS\‪Extbase\Persistence\PersistenceManagerInterface::class);

        ‪$mockPersistenceManager->expects($this->once())->method('remove')->with($object);

        $this->inject($this->repository, 'persistenceManager', ‪$mockPersistenceManager);

        $this->repository->_set('objectType', get_class($object));

        $this->repository->remove($object);

    }


    public function ‪updateDelegatesToPersistenceManager()

    {

        $object = new \stdClass();

        ‪$mockPersistenceManager = $this->createMock(\‪TYPO3\CMS\‪Extbase\Persistence\PersistenceManagerInterface::class);

        ‪$mockPersistenceManager->expects($this->once())->method('update')->with($object);

        $this->inject($this->repository, 'persistenceManager', ‪$mockPersistenceManager);

        $this->repository->_set('objectType', get_class($object));

        $this->repository->update($object);

    }


    public function ‪magicCallMethodAcceptsFindBySomethingCallsAndExecutesAQueryWithThatCriteria()

    {

        $mockQueryResult = $this->createMock(\‪TYPO3\CMS\‪Extbase\Persistence\QueryResultInterface::class);

        ‪$mockQuery = $this->createMock(\‪TYPO3\CMS\‪Extbase\Persistence\QueryInterface::class);

        ‪$mockQuery->expects($this->once())->method('equals')->with('foo', 'bar')->will($this->returnValue('matchCriteria'));

        ‪$mockQuery->expects($this->once())->method('matching')->with('matchCriteria')->will($this->returnValue(‪$mockQuery));

        ‪$mockQuery->expects($this->once())->method('execute')->with()->will($this->returnValue($mockQueryResult));


        ‪$repository = $this->getMockBuilder(\‪TYPO3\CMS\‪Extbase\Persistence\Repository::class)

            ->setMethods(['createQuery'])

            ->setConstructorArgs([$this->mockObjectManager])

            ->getMock();

        ‪$repository->expects($this->once())->method('createQuery')->will($this->returnValue(‪$mockQuery));


        $this->assertSame($mockQueryResult, ‪$repository->findByFoo('bar'));

    }


    public function ‪magicCallMethodAcceptsFindOneBySomethingCallsAndExecutesAQueryWithThatCriteria()

    {

        $object = new \stdClass();

        $mockQueryResult = $this->createMock(\‪TYPO3\CMS\‪Extbase\Persistence\QueryResultInterface::class);

        $mockQueryResult->expects($this->once())->method('getFirst')->will($this->returnValue($object));

        ‪$mockQuery = $this->createMock(\‪TYPO3\CMS\‪Extbase\Persistence\QueryInterface::class);

        ‪$mockQuery->expects($this->once())->method('equals')->with('foo', 'bar')->will($this->returnValue('matchCriteria'));

        ‪$mockQuery->expects($this->once())->method('matching')->with('matchCriteria')->will($this->returnValue(‪$mockQuery));

        ‪$mockQuery->expects($this->once())->method('setLimit')->will($this->returnValue(‪$mockQuery));

        ‪$mockQuery->expects($this->once())->method('execute')->will($this->returnValue($mockQueryResult));


        ‪$repository = $this->getMockBuilder(\‪TYPO3\CMS\‪Extbase\Persistence\Repository::class)

            ->setMethods(['createQuery'])

            ->setConstructorArgs([$this->mockObjectManager])

            ->getMock();

        ‪$repository->expects($this->once())->method('createQuery')->will($this->returnValue(‪$mockQuery));


        $this->assertSame($object, ‪$repository->findOneByFoo('bar'));

    }


    public function ‪magicCallMethodAcceptsCountBySomethingCallsAndExecutesAQueryWithThatCriteria()

    {

        ‪$mockQuery = $this->createMock(\‪TYPO3\CMS\‪Extbase\Persistence\QueryInterface::class);

        $mockQueryResult = $this->createMock(\‪TYPO3\CMS\‪Extbase\Persistence\QueryResultInterface::class);

        ‪$mockQuery->expects($this->once())->method('equals')->with('foo', 'bar')->will($this->returnValue('matchCriteria'));

        ‪$mockQuery->expects($this->once())->method('matching')->with('matchCriteria')->will($this->returnValue(‪$mockQuery));

        ‪$mockQuery->expects($this->once())->method('execute')->will($this->returnValue($mockQueryResult));

        $mockQueryResult->expects($this->once())->method('count')->will($this->returnValue(2));


        ‪$repository = $this->getMockBuilder(\‪TYPO3\CMS\‪Extbase\Persistence\Repository::class)

            ->setMethods(['createQuery'])

            ->setConstructorArgs([$this->mockObjectManager])

            ->getMock();

        ‪$repository->expects($this->once())->method('createQuery')->will($this->returnValue(‪$mockQuery));


        $this->assertSame(2, ‪$repository->countByFoo('bar'));

    }


    public function ‪magicCallMethodTriggersAnErrorIfUnknownMethodsAreCalled()

    {

        $this->expectException(UnsupportedMethodException::class);

        $this->expectExceptionCode(1233180480);

        ‪$repository = $this->getMockBuilder(\‪TYPO3\CMS\‪Extbase\Persistence\Repository::class)

            ->setMethods(['createQuery'])

            ->setConstructorArgs([$this->mockObjectManager])

            ->getMock();

        ‪$repository->__call('foo', []);

    }


    public function ‪addChecksObjectType()

    {

        $this->expectException(IllegalObjectTypeException::class);

        $this->expectExceptionCode(1248363335);

        $this->repository->_set('objectType', 'ExpectedObjectType');

        $this->repository->add(new \stdClass());

    }


    public function ‪removeChecksObjectType()

    {

        $this->expectException(IllegalObjectTypeException::class);

        $this->expectExceptionCode(1248363336);

        $this->repository->_set('objectType', 'ExpectedObjectType');

        $this->repository->remove(new \stdClass());

    }


    public function ‪updateChecksObjectType()

    {

        $this->expectException(IllegalObjectTypeException::class);

        $this->expectExceptionCode(1249479625);

        ‪$repository = $this->getAccessibleMock(\‪TYPO3\CMS\‪Extbase\Persistence\Repository::class, ['dummy'], [$this->mockObjectManager]);

        ‪$repository->_set('objectType', 'ExpectedObjectType');


        ‪$repository->update(new \stdClass());

    }


    public function ‪constructSetsObjectTypeFromClassName()

    {

        ‪$repository = new ‪Fixture\Domain\Repository\EntityRepository($this->mockObjectManager);


        $reflectionClass = new \ReflectionClass(‪$repository);

        $reflectionProperty = $reflectionClass->getProperty('objectType');

        $reflectionProperty->setAccessible(true);

        $objectType = $reflectionProperty->getValue(‪$repository);


        $this->assertEquals(Fixture\Domain\Model\Entity::class, $objectType);

    }


    public function ‪createQueryReturnsQueryWithUnmodifiedDefaultQuerySettings()

    {

        $this->mockQuery = new \TYPO3\CMS\Extbase\Persistence\Generic\Query('foo');

        $mockDefaultQuerySettings = $this->createMock(\‪TYPO3\CMS\‪Extbase\Persistence\Generic\QuerySettingsInterface::class);

        $this->repository->setDefaultQuerySettings($mockDefaultQuerySettings);

        $query = $this->repository->createQuery();

        $instanceQuerySettings = $query->getQuerySettings();

        $this->assertEquals($mockDefaultQuerySettings, $instanceQuerySettings);

        $this->assertNotSame($mockDefaultQuerySettings, $instanceQuerySettings);

    }


    public function ‪findByUidReturnsResultOfGetObjectByIdentifierCall()

    {

        $fakeUid = '123';

        $object = new \stdClass();

        ‪$repository = $this->getMockBuilder(\‪TYPO3\CMS\‪Extbase\Persistence\Repository::class)

            ->setMethods(['findByIdentifier'])

            ->setConstructorArgs([$this->mockObjectManager])

            ->getMock();

        $expectedResult = $object;

        ‪$repository->expects($this->once())->method('findByIdentifier')->will($this->returnValue($object));

        $actualResult = ‪$repository->findByUid($fakeUid);

        $this->assertSame($expectedResult, $actualResult);

    }


    public function ‪updateRejectsObjectsOfWrongType()

    {

        $this->expectException(IllegalObjectTypeException::class);

        $this->expectExceptionCode(1249479625);

        $this->repository->_set('objectType', 'Foo');

        $this->repository->update(new \stdClass());

    }


    public function ‪magicCallMethodReturnsFirstArrayKeyInFindOneBySomethingIfQueryReturnsRawResult()

    {

        $queryResultArray = [

            0 => [

                'foo' => 'bar',

            ],

        ];

        $this->mockQuery->expects($this->once())->method('equals')->with('foo', 'bar')->will($this->returnValue('matchCriteria'));

        $this->mockQuery->expects($this->once())->method('matching')->with('matchCriteria')->will($this->returnValue($this->mockQuery));

        $this->mockQuery->expects($this->once())->method('setLimit')->with(1)->will($this->returnValue($this->mockQuery));

        $this->mockQuery->expects($this->once())->method('execute')->will($this->returnValue($queryResultArray));

        $this->assertSame(['foo' => 'bar'], $this->repository->findOneByFoo('bar'));

    }


    public function ‪magicCallMethodReturnsNullInFindOneBySomethingIfQueryReturnsEmptyRawResult()

    {

        $queryResultArray = [];

        $this->mockQuery->expects($this->once())->method('equals')->with('foo', 'bar')->will($this->returnValue('matchCriteria'));

        $this->mockQuery->expects($this->once())->method('matching')->with('matchCriteria')->will($this->returnValue($this->mockQuery));

        $this->mockQuery->expects($this->once())->method('setLimit')->with(1)->will($this->returnValue($this->mockQuery));

        $this->mockQuery->expects($this->once())->method('execute')->will($this->returnValue($queryResultArray));

        $this->assertNull($this->repository->findOneByFoo('bar'));

    }

}