TranslatableRepositoryFactoryTest::testTranslatableRepository() - Code Metrics - Inspection of "Move more code from bundles to components" - php-lug/lug - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 74c3c7...591b88 )

by Eric

created 2016-02-27 11:48 UTC

testTranslatableRepository() B

↳ Parent: TranslatableRepositoryFactoryTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	38
Code Lines	28

Duplication

Lines	38
Ratio	100 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	38
loc	38
rs	8.8571
cc	1
eloc	28
nc	1
nop	0

<?php

/*
 * This file is part of the Lug package.
 *
 * (c) Eric GELOEN <[email protected]>
 *
 * For the full copyright and license information, please read the LICENSE
 * file that was distributed with this source code.
 */

namespace Lug\Component\Translation\Tests\Repository\Doctrine\MongoDB;

use Doctrine\ODM\MongoDB\Configuration;
use Doctrine\ODM\MongoDB\DocumentManager;
use Doctrine\ODM\MongoDB\DocumentRepository;
use Doctrine\ODM\MongoDB\Mapping\ClassMetadata;
use Doctrine\ODM\MongoDB\UnitOfWork;
use Lug\Component\Registry\Model\RegistryInterface;
use Lug\Component\Resource\Model\ResourceInterface;
use Lug\Component\Resource\Repository\Doctrine\MongoDB\Repository;
use Lug\Component\Resource\Repository\Doctrine\MongoDB\RepositoryFactory;
use Lug\Component\Translation\Context\LocaleContextInterface;
use Lug\Component\Translation\Repository\Doctrine\MongoDB\TranslatableRepository;
use Lug\Component\Translation\Repository\Doctrine\MongoDB\TranslatableRepositoryFactory;
use Symfony\Component\DependencyInjection\ContainerInterface;

/**
 * @author GeLo <[email protected]>
 */
class TranslatableRepositoryFactoryTest extends \PHPUnit_Framework_TestCase
{
    /**
     * @var TranslatableRepositoryFactory
     */
    private $repositoryFactory;

    /**
     * @var \PHPUnit_Framework_MockObject_MockObject|ContainerInterface
     */
    private $container;

    /**
     * @var \PHPUnit_Framework_MockObject_MockObject|RegistryInterface
     */
    private $resourceRegistry;

    /**
     * @var \PHPUnit_Framework_MockObject_MockObject|LocaleContextInterface
     */
    private $localeContext;

    /**
     * {@inheritdoc}
     */
    protected function setUp()
    {
        if (!class_exists(DocumentManager::class)) {
            $this->markTestSkipped();
        }

        $this->resourceRegistry = $this->createServiceRegistryMock();
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}
        $this->localeContext = $this->createLocaleContextMock();
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}

        $this->container = $this->createContainerMock();
        $this->container
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.
}
            ->expects($this->atLeast(1))
            ->method('get')
            ->will($this->returnValueMap([
                [
                    'lug.resource.registry',
                    ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE,
                    $this->resourceRegistry,
                ],
                [
                    'lug.translation.context.locale',
                    ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE,
                    $this->localeContext,
                ],
            ]));

        $this->repositoryFactory = new TranslatableRepositoryFactory($this->container);
    }

    public function testInheritance()
    {
        $this->assertInstanceOf(RepositoryFactory::class, $this->repositoryFactory);
    }

    public function testRepository()

    {
        $documentManager = $this->createDocumentManagerMock();
        $documentManager
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.
}
            ->expects($this->exactly(2))
            ->method('getClassMetadata')
            ->with($this->identicalTo($documentName = 'document'))
            ->will($this->returnValue($classMetadata = $this->createClassMetadataMock()));

        $documentManager
            ->expects($this->exactly(2))
            ->method('getConfiguration')
            ->will($this->returnValue($configuration = $this->createConfigurationMock()));

        $configuration
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.
}
            ->expects($this->exactly(2))
            ->method('getDefaultRepositoryClassName')
            ->will($this->returnValue($repositoryClass = DocumentRepository::class));

        $classMetadata
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.
}
            ->expects($this->exactly(2))
            ->method('getName')
            ->will($this->returnValue($documentName));

        $this->resourceRegistry
            ->expects($this->once())
            ->method('getIterator')
            ->will($this->returnValue(new \ArrayIterator([])));

        $documentManager
            ->expects($this->once())
            ->method('getUnitOfWork')
            ->will($this->returnValue($this->createUnitOfWorkMock()));

        $this->assertInstanceOf(
            $repositoryClass,
            $repository = $this->repositoryFactory->getRepository($documentManager, $documentName)
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        );

        $this->assertSame($repository, $this->repositoryFactory->getRepository($documentManager, $documentName));
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
    }

    public function testResourceRepository()

    {
        $documentManager = $this->createDocumentManagerMock();
        $documentManager
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.
}
            ->expects($this->once())
            ->method('getClassMetadata')
            ->with($this->identicalTo($documentName = 'document'))
            ->will($this->returnValue($classMetadata = $this->createClassMetadataMock()));

        $classMetadata
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.
}
            ->expects($this->once())
            ->method('getName')
            ->will($this->returnValue($documentName));

        $this->resourceRegistry
            ->expects($this->once())
            ->method('getIterator')
            ->will($this->returnValue(new \ArrayIterator([$resource = $this->createResourceMock()])));

        $resource
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.
}
            ->expects($this->once())
            ->method('getModel')
            ->will($this->returnValue($documentName));

        $documentManager
            ->expects($this->once())
            ->method('getUnitOfWork')
            ->will($this->returnValue($this->createUnitOfWorkMock()));

        $classMetadata->customRepositoryClassName = $repositoryClass = Repository::class;

        $this->assertInstanceOf(
            $repositoryClass,
            $repository = $this->repositoryFactory->getRepository($documentManager, $documentName)
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        );

        $this->assertSame($repository, $this->repositoryFactory->getRepository($documentManager, $documentName));
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
    }

    public function testTranslatableRepository()

    {
        $documentManager = $this->createDocumentManagerMock();
        $documentManager
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.
}
            ->expects($this->once())
            ->method('getClassMetadata')
            ->with($this->identicalTo($documentName = 'document'))
            ->will($this->returnValue($classMetadata = $this->createClassMetadataMock()));

        $classMetadata
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.
}
            ->expects($this->once())
            ->method('getName')
            ->will($this->returnValue($documentName));

        $this->resourceRegistry
            ->expects($this->once())
            ->method('getIterator')
            ->will($this->returnValue(new \ArrayIterator([$resource = $this->createResourceMock()])));

        $resource
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.
}
            ->expects($this->once())
            ->method('getModel')
            ->will($this->returnValue($documentName));

        $documentManager
            ->expects($this->once())
            ->method('getUnitOfWork')
            ->will($this->returnValue($this->createUnitOfWorkMock()));

        $classMetadata->customRepositoryClassName = $repositoryClass = TranslatableRepository::class;

        $this->assertInstanceOf(
            $repositoryClass,
            $repository = $this->repositoryFactory->getRepository($documentManager, $documentName)
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        );

        $this->assertSame($repository, $this->repositoryFactory->getRepository($documentManager, $documentName));
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject|RegistryInterface
     */
    private function createServiceRegistryMock()
    {
        return $this->getMock(RegistryInterface::class);
    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject|ContainerInterface
     */
    private function createContainerMock()
    {
        return $this->getMock(ContainerInterface::class);
    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject|LocaleContextInterface
     */
    private function createLocaleContextMock()
    {
        return $this->getMock(LocaleContextInterface::class);
    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject|DocumentManager
     */
    private function createDocumentManagerMock()
    {
        return $this->getMockBuilder(DocumentManager::class)
            ->disableOriginalConstructor()
            ->getMock();
    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject|UnitOfWork
     */
    public function createUnitOfWorkMock()
    {
        return $this->getMockBuilder(UnitOfWork::class)
            ->disableOriginalConstructor()
            ->getMock();
    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject|ClassMetadata
     */
    private function createClassMetadataMock()
    {
        return $this->getMockBuilder(ClassMetadata::class)
            ->disableOriginalConstructor()
            ->getMock();
    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject|Configuration
     */
    private function createConfigurationMock()
    {
        return $this->getMock(Configuration::class);
    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject|ResourceInterface
     */
    private function createResourceMock()
    {
        return $this->getMock(ResourceInterface::class);
    }
}


Push — master ( 74c3c7...591b88 )

testTranslatableRepository() B

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1			<?php
2
3			/*
4			* This file is part of the Lug package.
5			*
6			* (c) Eric GELOEN <[email protected]>
7			*
8			* For the full copyright and license information, please read the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace Lug\Component\Translation\Tests\Repository\Doctrine\MongoDB;
13
14			use Doctrine\ODM\MongoDB\Configuration;
15			use Doctrine\ODM\MongoDB\DocumentManager;
16			use Doctrine\ODM\MongoDB\DocumentRepository;
17			use Doctrine\ODM\MongoDB\Mapping\ClassMetadata;
18			use Doctrine\ODM\MongoDB\UnitOfWork;
19			use Lug\Component\Registry\Model\RegistryInterface;
20			use Lug\Component\Resource\Model\ResourceInterface;
21			use Lug\Component\Resource\Repository\Doctrine\MongoDB\Repository;
22			use Lug\Component\Resource\Repository\Doctrine\MongoDB\RepositoryFactory;
23			use Lug\Component\Translation\Context\LocaleContextInterface;
24			use Lug\Component\Translation\Repository\Doctrine\MongoDB\TranslatableRepository;
25			use Lug\Component\Translation\Repository\Doctrine\MongoDB\TranslatableRepositoryFactory;
26			use Symfony\Component\DependencyInjection\ContainerInterface;
27
28			/**
29			* @author GeLo <[email protected]>
30			*/
31			class TranslatableRepositoryFactoryTest extends \PHPUnit_Framework_TestCase
32			{
33			/**
34			* @var TranslatableRepositoryFactory
35			*/
36			private $repositoryFactory;
37
38			/**
39			* @var \PHPUnit_Framework_MockObject_MockObject\|ContainerInterface
40			*/

php-lug / lug

Push — master ( 74c3c7...591b88 )

testTranslatableRepository() B

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like