RelationalBuilderTest::testQueryCache() - Code Metrics - Inspection of "metadata driver as default driver" - juliangut/doctrine-manager-builder - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 63cb48...b7ca1d )

by Julián

created 2016-09-14 22:39 UTC

RelationalBuilderTest::testQueryCache() A

↳ Parent: RelationalBuilderTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	14
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	14
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	8
nc	1
nop	0

<?php
/**
 * doctrine-manager-builder (https://github.com/juliangut/doctrine-manager-builder)
 * Doctrine2 managers builder
 *
 * @license BSD-3-Clause
 * @author Julián Gutiérrez <[email protected]>
 */

namespace Jgut\Doctrine\ManagerBuilder\Tests;

use Doctrine\Common\Cache\ArrayCache;
use Doctrine\Common\Cache\CacheProvider;
use Doctrine\Common\Cache\VoidCache;
use Doctrine\Common\Persistence\Mapping\Driver\StaticPHPDriver;
use Doctrine\DBAL\Logging\EchoSQLLogger;
use Doctrine\DBAL\Types\StringType;
use Doctrine\ORM\EntityManager;
use Jgut\Doctrine\ManagerBuilder\ManagerBuilder;
use Jgut\Doctrine\ManagerBuilder\RelationalBuilder;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Helper\HelperSet;

/**
 * Relational entity builder tests.
 */
class RelationalBuilderTest extends \PHPUnit_Framework_TestCase
{
    /**
     * @var RelationalBuilder
     */
    protected $builder;

    /**
     * {@inheritdoc}
     */
    public function setUp()
    {
        $this->builder = new RelationalBuilder([], 'test');
    }

    public function testQueryCache()
    {
        $cacheDriver = $this->getMockBuilder(VoidCache::class)
            ->disableOriginalConstructor()
            ->setMethodsExcept(['getNamespace', 'setNamespace'])
            ->getMock();

        $this->builder->setOption('query_cache_driver', $cacheDriver);
        $this->builder->setOption('query_cache_namespace', 'namespace');

        /* @var CacheProvider $driver */
        $driver = $this->builder->getQueryCacheDriver();
        self::assertEquals($cacheDriver, $driver);
        self::assertEquals('namespace', $driver->getNamespace());

        /* @var CacheProvider $cacheDriver */
        $cacheDriver = $this->getMockBuilder(ArrayCache::class)
            ->disableOriginalConstructor()
            ->setMethodsExcept(['getNamespace'])
            ->getMock();
        $this->builder->setQueryCacheDriver($cacheDriver);

        self::assertEquals($cacheDriver, $this->builder->getQueryCacheDriver());
    }

    public function testResultCache()
    {
        $cacheDriver = $this->getMockBuilder(VoidCache::class)
            ->disableOriginalConstructor()
            ->setMethodsExcept(['getNamespace', 'setNamespace'])
            ->getMock();

        $this->builder->setOption('result_cache_driver', $cacheDriver);
        $this->builder->setOption('result_cache_namespace', '');

        self::assertInstanceOf(CacheProvider::class, $this->builder->getResultCacheDriver());

        /* @var CacheProvider $cacheDriver */
        $cacheDriver = $this->getMockBuilder(VoidCache::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->builder->setResultCacheDriver($cacheDriver);

        self::assertEquals($cacheDriver, $this->builder->getResultCacheDriver());
    }

    /**
     * @expectedException \RuntimeException
     * @expectedExceptionMessageRegExp /^".+" file does not exist$/
     */
    public function testManagerNoAnnotationFile()
    {
        $this->builder->setOption('annotation_files', __DIR__ . '/fake_file.php');

        $this->builder->getManager(true, true);
    }

    /**
     * @expectedException \RuntimeException
     * @expectedExceptionMessage No metadata mapping defined
     */
    public function testManagerNoMetadataMapping()
    {
        $this->builder->getManager();
    }

    /**
     * @expectedException \RuntimeException
     * @expectedExceptionMessage metadata_mapping must be array with "driver" key or "type" and "path" keys
     */
    public function testManagerNoMappingDriver()
    {
        $this->builder->setOption('metadata_mapping', [[]]);

        $this->builder->getManager(true, true);
    }

    /**
     * @expectedException \RuntimeException
     * @expectedExceptionMessageRegExp /^Provided driver should be of the type MappingDriver, ".+" given$/
     */
    public function testManagerWrongMappingDriver()
    {
        $this->builder->setOption('metadata_mapping', [__DIR__]);

        $this->builder->getManager(true, true);
    }

    /**
     * @expectedException \UnexpectedValueException
     * @expectedExceptionMessageRegExp /^".+" is not a valid metadata mapping type$/
     */
    public function testManagerWrongMappingType()
    {
        $this->builder->setOption('metadata_mapping', [['type' => 'unknown', 'path' => __DIR__]]);

        $this->builder->getManager(true, true);
    }

    /**
     * @expectedException \RuntimeException
     * @expectedExceptionMessage Only one default metadata mapping driver allowed, a namespace must be defined
     */
    public function testManagerSingleDefaultMapping()
    {
        $this->builder->setOption(
            'metadata_mapping',
            [
                ['driver' => new StaticPHPDriver([__DIR__])],
                ['type' => ManagerBuilder::METADATA_MAPPING_XML, 'path' => __DIR__, 'namespace' => 'namespace'],
                ['type' => ManagerBuilder::METADATA_MAPPING_YAML, 'path' => __DIR__],
            ]
        );

        $this->builder->getManager(true, true);
    }

    /**
     * @expectedException \Doctrine\DBAL\DBALException
     * @expectedExceptionMessageRegExp /^The options 'driver' or 'driverClass' are mandatory if no PDO instance/
     */
    public function testManagerNoConnection()
    {
        $this->builder->setOption(
            'metadata_mapping',
            [
                ['type' => ManagerBuilder::METADATA_MAPPING_ANNOTATION, 'path' => __DIR__, 'namespace' => 'annotation'],
                ['type' => ManagerBuilder::METADATA_MAPPING_XML, 'path' => __DIR__, 'namespace' => 'xml'],
                ['type' => ManagerBuilder::METADATA_MAPPING_YAML, 'path' => __DIR__, 'namespace' => 'yaml'],
                ['type' => ManagerBuilder::METADATA_MAPPING_PHP, 'path' => __DIR__, 'namespace' => 'php'],
            ]
        );

        $this->builder->getManager(true, true);
    }

    public function testManager()
    {
        $this->builder->setOption('annotation_files', __FILE__);
        $this->builder->setOption('annotation_namespaces', ['namespace' => __FILE__]);
        $this->builder->setOption('annotation_autoloaders', ['class_exists']);
        $this->builder->setOption('connection', ['driver' => 'pdo_sqlite', 'memory' => true]);
        $this->builder->setOption(
            'metadata_mapping',
            [['type' => ManagerBuilder::METADATA_MAPPING_ANNOTATION, 'path' => __DIR__]]
        );
        $this->builder->setOption('sql_logger', new EchoSQLLogger);
        $this->builder->setOption('custom_string_functions', 'string');
        $this->builder->setOption('custom_numeric_functions', 'numeric');
        $this->builder->setOption('custom_datetime_functions', 'datetime');
        $this->builder->setOption('custom_types', ['fake_type' => StringType::class]);

        static::assertInstanceOf(EntityManager::class, $this->builder->getManager(true));
    }

    public function testConsoleCommands()
    {
        $this->builder->setOption('connection', ['driver' => 'pdo_sqlite', 'memory' => true]);
        $this->builder->setOption(
            'metadata_mapping',
            [['type' => ManagerBuilder::METADATA_MAPPING_ANNOTATION, 'path' => __DIR__]]
        );

        $commands = $this->builder->getConsoleCommands();

        return array_walk(
            $commands,
            function ($command) {
                static::assertInstanceOf(Command::class, $command);
            }
        );
    }

    public function testConsoleHelperSet()
    {
        $this->builder->setOption('connection', ['driver' => 'pdo_sqlite', 'memory' => true]);
        $this->builder->setOption(
            'metadata_mapping',
            [['type' => ManagerBuilder::METADATA_MAPPING_ANNOTATION, 'path' => __DIR__]]
        );

        $helperSet = $this->builder->getConsoleHelperSet();

        static::assertInstanceOf(HelperSet::class, $helperSet);
        static::assertTrue($helperSet->has('connection'));
        static::assertTrue($helperSet->has('db'));
        static::assertTrue($helperSet->has('entityManager'));
        static::assertTrue($helperSet->has('em'));
    }
}


1			<?php
2			/**
3			* doctrine-manager-builder (https://github.com/juliangut/doctrine-manager-builder)
4			* Doctrine2 managers builder
5			*
6			* @license BSD-3-Clause
7			* @author Julián Gutiérrez <[email protected]>
8			*/
9
10			namespace Jgut\Doctrine\ManagerBuilder\Tests;
11
12			use Doctrine\Common\Cache\ArrayCache;
13			use Doctrine\Common\Cache\CacheProvider;
14			use Doctrine\Common\Cache\VoidCache;
15			use Doctrine\Common\Persistence\Mapping\Driver\StaticPHPDriver;
16			use Doctrine\DBAL\Logging\EchoSQLLogger;
17			use Doctrine\DBAL\Types\StringType;
18			use Doctrine\ORM\EntityManager;
19			use Jgut\Doctrine\ManagerBuilder\ManagerBuilder;
20			use Jgut\Doctrine\ManagerBuilder\RelationalBuilder;
21			use Symfony\Component\Console\Command\Command;
22			use Symfony\Component\Console\Helper\HelperSet;
23
24			/**
25			* Relational entity builder tests.
26			*/
27			class RelationalBuilderTest extends \PHPUnit_Framework_TestCase
28			{
29			/**
30			* @var RelationalBuilder
31			*/
32			protected $builder;
33
34			/**
35			* {@inheritdoc}
36			*/
37			public function setUp()
38			{
39			$this->builder = new RelationalBuilder([], 'test');
40			}
41
42			public function testQueryCache()
43			{
44			$cacheDriver = $this->getMockBuilder(VoidCache::class)
45			->disableOriginalConstructor()
46			->setMethodsExcept(['getNamespace', 'setNamespace'])
47			->getMock();
48
49			$this->builder->setOption('query_cache_driver', $cacheDriver);
50			$this->builder->setOption('query_cache_namespace', 'namespace');
51
52			/* @var CacheProvider $driver */
53			$driver = $this->builder->getQueryCacheDriver();
54			self::assertEquals($cacheDriver, $driver);
55			self::assertEquals('namespace', $driver->getNamespace());
56
57			/* @var CacheProvider $cacheDriver */
58			$cacheDriver = $this->getMockBuilder(ArrayCache::class)
59			->disableOriginalConstructor()
60			->setMethodsExcept(['getNamespace'])
61			->getMock();
62			$this->builder->setQueryCacheDriver($cacheDriver);
63
64			self::assertEquals($cacheDriver, $this->builder->getQueryCacheDriver());
65			}
66
67			public function testResultCache()
68			{
69			$cacheDriver = $this->getMockBuilder(VoidCache::class)
70			->disableOriginalConstructor()
71			->setMethodsExcept(['getNamespace', 'setNamespace'])
72			->getMock();
73
74			$this->builder->setOption('result_cache_driver', $cacheDriver);
75			$this->builder->setOption('result_cache_namespace', '');
76
77			self::assertInstanceOf(CacheProvider::class, $this->builder->getResultCacheDriver());
78
79			/* @var CacheProvider $cacheDriver */
80			$cacheDriver = $this->getMockBuilder(VoidCache::class)
81			->disableOriginalConstructor()
82			->getMock();
83			$this->builder->setResultCacheDriver($cacheDriver);
84
85			self::assertEquals($cacheDriver, $this->builder->getResultCacheDriver());
86			}
87
88			/**
89			* @expectedException \RuntimeException
90			* @expectedExceptionMessageRegExp /^".+" file does not exist$/
91			*/
92			public function testManagerNoAnnotationFile()
93			{
94			$this->builder->setOption('annotation_files', __DIR__ . '/fake_file.php');
95
96			$this->builder->getManager(true, true);
97			}
98
99			/**
100			* @expectedException \RuntimeException
101			* @expectedExceptionMessage No metadata mapping defined
102			*/
103			public function testManagerNoMetadataMapping()
104			{
105			$this->builder->getManager();
106			}
107
108			/**
109			* @expectedException \RuntimeException
110			* @expectedExceptionMessage metadata_mapping must be array with "driver" key or "type" and "path" keys
111			*/
112			public function testManagerNoMappingDriver()
113			{
114			$this->builder->setOption('metadata_mapping', [[]]);
115
116			$this->builder->getManager(true, true);
117			}
118
119			/**
120			* @expectedException \RuntimeException
121			* @expectedExceptionMessageRegExp /^Provided driver should be of the type MappingDriver, ".+" given$/
122			*/
123			public function testManagerWrongMappingDriver()
124			{
125			$this->builder->setOption('metadata_mapping', [__DIR__]);
126
127			$this->builder->getManager(true, true);
128			}
129
130			/**
131			* @expectedException \UnexpectedValueException
132			* @expectedExceptionMessageRegExp /^".+" is not a valid metadata mapping type$/
133			*/
134			public function testManagerWrongMappingType()
135			{
136			$this->builder->setOption('metadata_mapping', [['type' => 'unknown', 'path' => __DIR__]]);
137
138			$this->builder->getManager(true, true);
139			}
140
141			/**
142			* @expectedException \RuntimeException
143			* @expectedExceptionMessage Only one default metadata mapping driver allowed, a namespace must be defined
144			*/
145			public function testManagerSingleDefaultMapping()
146			{
147			$this->builder->setOption(
148			'metadata_mapping',
149			[
150			['driver' => new StaticPHPDriver([__DIR__])],
151			['type' => ManagerBuilder::METADATA_MAPPING_XML, 'path' => __DIR__, 'namespace' => 'namespace'],
152			['type' => ManagerBuilder::METADATA_MAPPING_YAML, 'path' => __DIR__],
153			]
154			);
155
156			$this->builder->getManager(true, true);
157			}
158
159			/**
160			* @expectedException \Doctrine\DBAL\DBALException
161			* @expectedExceptionMessageRegExp /^The options 'driver' or 'driverClass' are mandatory if no PDO instance/
162			*/
163			public function testManagerNoConnection()
164			{
165			$this->builder->setOption(
166			'metadata_mapping',
167			[
168			['type' => ManagerBuilder::METADATA_MAPPING_ANNOTATION, 'path' => __DIR__, 'namespace' => 'annotation'],
169			['type' => ManagerBuilder::METADATA_MAPPING_XML, 'path' => __DIR__, 'namespace' => 'xml'],
170			['type' => ManagerBuilder::METADATA_MAPPING_YAML, 'path' => __DIR__, 'namespace' => 'yaml'],
171			['type' => ManagerBuilder::METADATA_MAPPING_PHP, 'path' => __DIR__, 'namespace' => 'php'],
172			]
173			);
174
175			$this->builder->getManager(true, true);
176			}
177
178			public function testManager()
179			{
180			$this->builder->setOption('annotation_files', __FILE__);
181			$this->builder->setOption('annotation_namespaces', ['namespace' => __FILE__]);
182			$this->builder->setOption('annotation_autoloaders', ['class_exists']);
183			$this->builder->setOption('connection', ['driver' => 'pdo_sqlite', 'memory' => true]);
184			$this->builder->setOption(
185			'metadata_mapping',
186			[['type' => ManagerBuilder::METADATA_MAPPING_ANNOTATION, 'path' => __DIR__]]
187			);
188			$this->builder->setOption('sql_logger', new EchoSQLLogger);
189			$this->builder->setOption('custom_string_functions', 'string');
190			$this->builder->setOption('custom_numeric_functions', 'numeric');
191			$this->builder->setOption('custom_datetime_functions', 'datetime');
192			$this->builder->setOption('custom_types', ['fake_type' => StringType::class]);
193
194			static::assertInstanceOf(EntityManager::class, $this->builder->getManager(true));
195			}
196
197			public function testConsoleCommands()
198			{
199			$this->builder->setOption('connection', ['driver' => 'pdo_sqlite', 'memory' => true]);
200			$this->builder->setOption(
201			'metadata_mapping',
202			[['type' => ManagerBuilder::METADATA_MAPPING_ANNOTATION, 'path' => __DIR__]]
203			);
204
205			$commands = $this->builder->getConsoleCommands();
206
207			return array_walk(
208			$commands,
209			function ($command) {
210			static::assertInstanceOf(Command::class, $command);
211			}
212			);
213			}
214
215			public function testConsoleHelperSet()
216			{
217			$this->builder->setOption('connection', ['driver' => 'pdo_sqlite', 'memory' => true]);
218			$this->builder->setOption(
219			'metadata_mapping',
220			[['type' => ManagerBuilder::METADATA_MAPPING_ANNOTATION, 'path' => __DIR__]]
221			);
222
223			$helperSet = $this->builder->getConsoleHelperSet();
224
225			static::assertInstanceOf(HelperSet::class, $helperSet);
226			static::assertTrue($helperSet->has('connection'));
227			static::assertTrue($helperSet->has('db'));
228			static::assertTrue($helperSet->has('entityManager'));
229			static::assertTrue($helperSet->has('em'));
230			}
231			}
232

juliangut / doctrine-manager-builder

Push — master ( 63cb48...b7ca1d )

RelationalBuilderTest::testQueryCache() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like