DriverManagerTest::testInvalidWrapperClass() - Code Metrics - Inspection of "Forward compatibility with 3.x" - doctrine/dbal - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Pull Request — master (#2996)

by Sergei

created 2018-01-31 07:38 UTC

DriverManagerTest::testInvalidWrapperClass() A

↳ Parent: DriverManagerTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	10
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	10
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	5
nc	1
nop	0

<?php

namespace Doctrine\Tests\DBAL;

use Doctrine\DBAL\DBALException;
use Doctrine\DBAL\Driver\DrizzlePDOMySql\Driver as DrizzlePDOMySqlDriver;
use Doctrine\DBAL\Driver\PDOMySQL\Driver as PDOMySQLDriver;
use Doctrine\DBAL\Driver\PDOSqlite\Driver as PDOSqliteDriver;
use Doctrine\DBAL\Driver\SQLSrv\Driver as SQLSrvDriver;
use Doctrine\DBAL\DriverManager;
use Doctrine\Tests\DBAL\Mocks\MockPlatform;
use Doctrine\Tests\DbalTestCase;
use Doctrine\Tests\Mocks\ConnectionMock;
use Doctrine\Tests\Mocks\DriverMock;
use stdClass;

class DriverManagerTest extends DbalTestCase
{
    /**
     * @requires extension pdo_sqlite
     * @expectedException \Doctrine\DBAL\DBALException
     */
    public function testInvalidPdoInstance()
    {
        DriverManager::getConnection(['pdo' => 'test']);
    }

    /**
     * @requires extension pdo_sqlite
     */
    public function testValidPdoInstance()
    {
        $conn = DriverManager::getConnection([
            'pdo' => new \PDO('sqlite::memory:'),
        ]);

        self::assertEquals('sqlite', $conn->getDatabasePlatform()->getName());
    }

    /**
     * @group DBAL-32
     * @requires extension pdo_sqlite
     */
    public function testPdoInstanceSetErrorMode()
    {
        $pdo = new \PDO('sqlite::memory:');
        $pdo->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_SILENT);
        $options = ['pdo' => $pdo];

        DriverManager::getConnection($options);
        self::assertEquals(\PDO::ERRMODE_EXCEPTION, $pdo->getAttribute(\PDO::ATTR_ERRMODE));
    }

    /**
     * @expectedException \Doctrine\DBAL\DBALException
     */
    public function testCheckParams()
    {
        DriverManager::getConnection([]);
    }

    /**
     * @expectedException \Doctrine\DBAL\DBALException
     */
    public function testInvalidDriver()
    {
        DriverManager::getConnection(['driver' => 'invalid_driver']);
    }

    /**
     * @requires extension pdo_sqlite
     */
    public function testCustomPlatform()
    {
        $mockPlatform = new MockPlatform();
        $options      = [
            'pdo'      => new \PDO('sqlite::memory:'),
            'platform' => $mockPlatform,
        ];

        $conn = DriverManager::getConnection($options);
        self::assertSame($mockPlatform, $conn->getDatabasePlatform());
    }

    /**
     * @requires extension pdo_sqlite
     */
    public function testCustomWrapper()
    {
        $wrapperClass = ConnectionMock::class;

        $options = [
            'pdo' => new \PDO('sqlite::memory:'),
            'wrapperClass' => $wrapperClass,
        ];

        $conn = DriverManager::getConnection($options);
        self::assertInstanceOf($wrapperClass, $conn);
    }

    /**
     * @requires extension pdo_sqlite
     */
    public function testInvalidWrapperClass()
    {
        $this->expectException(DBALException::class);

        $options = [
            'pdo' => new \PDO('sqlite::memory:'),
            'wrapperClass' => stdClass::class,
        ];

        DriverManager::getConnection($options);
    }

    public function testInvalidDriverClass()
    {
        $this->expectException(DBALException::class);

        $options = ['driverClass' => stdClass::class];

        DriverManager::getConnection($options);
    }

    public function testValidDriverClass()
    {
        $options = ['driverClass' => PDOMySQLDriver::class];

        $conn = DriverManager::getConnection($options);
        self::assertInstanceOf(PDOMySQLDriver::class, $conn->getDriver());
    }

    /**
     * @dataProvider databaseUrls
     */
    public function testDatabaseUrl($url, $expected)
    {
        $options = is_array($url) ? $url : ['url' => $url];

        if (isset($options['pdo'])) {
            if (! extension_loaded('pdo')) {
                $this->markTestSkipped('PDO is not installed');
            }

            $options['pdo'] = $this->createMock(\PDO::class);
        }

        $options = is_array($url) ? $url : ['url' => $url];

        if ($expected === false) {
            $this->expectException(DBALException::class);
        }

        $conn = DriverManager::getConnection($options);

        $params = $conn->getParams();
        foreach ($expected as $key => $value) {
            if (in_array($key, ['pdo', 'driver', 'driverClass'], true)) {
                self::assertInstanceOf($value, $conn->getDriver());
            } else {
                self::assertEquals($value, $params[$key]);
            }
        }
    }

    public function databaseUrls()
    {
        return [
            'simple URL' => [
                'mysql://foo:bar@localhost/baz',
                [
                    'user'     => 'foo',
                    'password' => 'bar',
                    'host'     => 'localhost',
                    'dbname'   => 'baz',
                    'driver'   => PDOMySQLDriver::class,
                ],
            ],
            'simple URL with port' => [
                'mysql://foo:bar@localhost:11211/baz',
                [
                    'user'     => 'foo',
                    'password' => 'bar',
                    'host'     => 'localhost',
                    'port'     => 11211,
                    'dbname'   => 'baz',
                    'driver'   => PDOMySQLDriver::class,
                ],
            ],
            'sqlite relative URL with host' => [
                'sqlite://localhost/foo/dbname.sqlite',
                [
                    'path'   => 'foo/dbname.sqlite',
                    'driver' => PDOSqliteDriver::class,
                ],
            ],
            'sqlite absolute URL with host' => [
                'sqlite://localhost//tmp/dbname.sqlite',
                [
                    'path'   => '/tmp/dbname.sqlite',
                    'driver' => PDOSqliteDriver::class,
                ],
            ],
            'sqlite relative URL without host' => [
                'sqlite:///foo/dbname.sqlite',
                [
                    'path'   => 'foo/dbname.sqlite',
                    'driver' => PDOSqliteDriver::class,
                ],
            ],
            'sqlite absolute URL without host' => [
                'sqlite:////tmp/dbname.sqlite',
                [
                    'path'   => '/tmp/dbname.sqlite',
                    'driver' => PDOSqliteDriver::class,
                ],
            ],
            'sqlite memory' => [
                'sqlite:///:memory:',
                [
                    'memory' => true,
                    'driver' => PDOSqliteDriver::class,
                ],
            ],
            'sqlite memory with host' => [
                'sqlite://localhost/:memory:',
                [
                    'memory' => true,
                    'driver' => PDOSqliteDriver::class,
                ],
            ],
            'params parsed from URL override individual params' => [
                [
                    'url'      => 'mysql://foo:bar@localhost/baz',
                    'password' => 'lulz',
                ],
                [
                    'user'     => 'foo',
                    'password' => 'bar',
                    'host'     => 'localhost',
                    'dbname'   => 'baz',
                    'driver'   => PDOMySQLDriver::class,
                ],
            ],
            'params not parsed from URL but individual params are preserved' => [
                [
                    'url'  => 'mysql://foo:bar@localhost/baz',
                    'port' => 1234,
                ],
                [
                    'user'     => 'foo',
                    'password' => 'bar',
                    'host'     => 'localhost',
                    'port'     => 1234,
                    'dbname'   => 'baz',
                    'driver'   => PDOMySQLDriver::class,
                ],
            ],
            'query params from URL are used as extra params' => [
                'url' => 'mysql://foo:bar@localhost/dbname?charset=UTF-8',
                ['charset' => 'UTF-8'],
            ],
            'simple URL with fallthrough scheme not defined in map' => [
                'sqlsrv://foo:bar@localhost/baz',
                [
                    'user'     => 'foo',
                    'password' => 'bar',
                    'host'     => 'localhost',
                    'dbname'   => 'baz',
                    'driver'   => SQLSrvDriver::class,
                ],
            ],
            'simple URL with fallthrough scheme containing underscores fails' => [
                'drizzle_pdo_mysql://foo:bar@localhost/baz',
                false,
            ],
            'simple URL with fallthrough scheme containing dashes works' => [
                'drizzle-pdo-mysql://foo:bar@localhost/baz',
                [
                    'user'     => 'foo',
                    'password' => 'bar',
                    'host'     => 'localhost',
                    'dbname'   => 'baz',
                    'driver'   => DrizzlePDOMySqlDriver::class,
                ],
            ],
            'simple URL with percent encoding' => [
                'mysql://foo%3A:bar%2F@localhost/baz+baz%40',
                [
                    'user'     => 'foo:',
                    'password' => 'bar/',
                    'host'     => 'localhost',
                    'dbname'   => 'baz+baz@',
                    'driver'   => PDOMySQLDriver::class,
                ],
            ],
            'simple URL with percent sign in password' => [
                'mysql://foo:bar%25bar@localhost/baz',
                [
                    'user'     => 'foo',
                    'password' => 'bar%bar',
                    'host'     => 'localhost',
                    'dbname'   => 'baz',
                    'driver'   => PDOMySQLDriver::class,
                ],
            ],

            // DBAL-1234
            'URL without scheme and without any driver information' => [
                ['url' => '//foo:bar@localhost/baz'],
                false,
            ],
            'URL without scheme but default PDO driver' => [
                [
                    'url' => '//foo:bar@localhost/baz',
                    'pdo' => true,
                ],
                false,
            ],
            'URL without scheme but default driver' => [
                [
                    'url'    => '//foo:bar@localhost/baz',
                    'driver' => 'pdo_mysql',
                ],
                [
                    'user'     => 'foo',
                    'password' => 'bar',
                    'host'     => 'localhost',
                    'dbname'   => 'baz',
                    'driver'   => PDOMySQLDriver::class,
                ],
            ],
            'URL without scheme but custom driver' => [
                [
                    'url'         => '//foo:bar@localhost/baz',
                    'driverClass' => DriverMock::class,
                ],
                [
                    'user'        => 'foo',
                    'password'    => 'bar',
                    'host'        => 'localhost',
                    'dbname'      => 'baz',
                    'driverClass' => DriverMock::class,
                ],
            ],
            'URL without scheme but default PDO driver and default driver' => [
                [
                    'url'    => '//foo:bar@localhost/baz',
                    'pdo'    => true,
                    'driver' => 'pdo_mysql',
                ],
                [
                    'user'     => 'foo',
                    'password' => 'bar',
                    'host'     => 'localhost',
                    'dbname'   => 'baz',
                    'driver'   => PDOMySQLDriver::class,
                ],
            ],
            'URL without scheme but driver and custom driver' => [
                [
                    'url'         => '//foo:bar@localhost/baz',
                    'driver'      => 'pdo_mysql',
                    'driverClass' => DriverMock::class,
                ],
                [
                    'user'        => 'foo',
                    'password'    => 'bar',
                    'host'        => 'localhost',
                    'dbname'      => 'baz',
                    'driverClass' => DriverMock::class,
                ],
            ],
            'URL with default PDO driver' => [
                [
                    'url' => 'mysql://foo:bar@localhost/baz',
                    'pdo' => true,
                ],
                [
                    'user'     => 'foo',
                    'password' => 'bar',
                    'host'     => 'localhost',
                    'dbname'   => 'baz',
                    'driver'   => PDOMySQLDriver::class,
                ],
            ],
            'URL with default driver' => [
                [
                    'url'    => 'mysql://foo:bar@localhost/baz',
                    'driver' => 'sqlite',
                ],
                [
                    'user'     => 'foo',
                    'password' => 'bar',
                    'host'     => 'localhost',
                    'dbname'   => 'baz',
                    'driver'   => PDOMySQLDriver::class,
                ],
            ],
            'URL with default custom driver' => [
                [
                    'url'         => 'mysql://foo:bar@localhost/baz',
                    'driverClass' => DriverMock::class,
                ],
                [
                    'user'     => 'foo',
                    'password' => 'bar',
                    'host'     => 'localhost',
                    'dbname'   => 'baz',
                    'driver'   => PDOMySQLDriver::class,
                ],
            ],
            'URL with default PDO driver and default driver' => [
                [
                    'url'    => 'mysql://foo:bar@localhost/baz',
                    'pdo'    => true,
                    'driver' => 'sqlite',
                ],
                [
                    'user'     => 'foo',
                    'password' => 'bar',
                    'host'     => 'localhost',
                    'dbname'   => 'baz',
                    'driver'   => PDOMySQLDriver::class,
                ],
            ],
            'URL with default driver and default custom driver' => [
                [
                    'url'         => 'mysql://foo:bar@localhost/baz',
                    'driver'      => 'sqlite',
                    'driverClass' => DriverMock::class,
                ],
                [
                    'user'     => 'foo',
                    'password' => 'bar',
                    'host'     => 'localhost',
                    'dbname'   => 'baz',
                    'driver'   => PDOMySQLDriver::class,
                ],
            ],
            'URL with default PDO driver and default driver and default custom driver' => [
                [
                    'url'         => 'mysql://foo:bar@localhost/baz',
                    'pdo'         => true,
                    'driver'      => 'sqlite',
                    'driverClass' => DriverMock::class,
                ],
                [
                    'user'     => 'foo',
                    'password' => 'bar',
                    'host'     => 'localhost',
                    'dbname'   => 'baz',
                    'driver'   => PDOMySQLDriver::class,
                ],
            ],
        ];
    }
}


1			<?php
2
3			namespace Doctrine\Tests\DBAL;
4
5			use Doctrine\DBAL\DBALException;
6			use Doctrine\DBAL\Driver\DrizzlePDOMySql\Driver as DrizzlePDOMySqlDriver;
7			use Doctrine\DBAL\Driver\PDOMySQL\Driver as PDOMySQLDriver;
8			use Doctrine\DBAL\Driver\PDOSqlite\Driver as PDOSqliteDriver;
9			use Doctrine\DBAL\Driver\SQLSrv\Driver as SQLSrvDriver;
10			use Doctrine\DBAL\DriverManager;
11			use Doctrine\Tests\DBAL\Mocks\MockPlatform;
12			use Doctrine\Tests\DbalTestCase;
13			use Doctrine\Tests\Mocks\ConnectionMock;
14			use Doctrine\Tests\Mocks\DriverMock;
15			use stdClass;
16
17			class DriverManagerTest extends DbalTestCase
18			{
19			/**
20			* @requires extension pdo_sqlite
21			* @expectedException \Doctrine\DBAL\DBALException
22			*/
23			public function testInvalidPdoInstance()
24			{
25			DriverManager::getConnection(['pdo' => 'test']);
26			}
27
28			/**
29			* @requires extension pdo_sqlite
30			*/
31			public function testValidPdoInstance()
32			{
33			$conn = DriverManager::getConnection([
34			'pdo' => new \PDO('sqlite::memory:'),
35			]);
36
37			self::assertEquals('sqlite', $conn->getDatabasePlatform()->getName());
38			}
39
40			/**
41			* @group DBAL-32
42			* @requires extension pdo_sqlite
43			*/
44			public function testPdoInstanceSetErrorMode()
45			{
46			$pdo = new \PDO('sqlite::memory:');
47			$pdo->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_SILENT);
48			$options = ['pdo' => $pdo];
49
50			DriverManager::getConnection($options);
51			self::assertEquals(\PDO::ERRMODE_EXCEPTION, $pdo->getAttribute(\PDO::ATTR_ERRMODE));
52			}
53
54			/**
55			* @expectedException \Doctrine\DBAL\DBALException
56			*/
57			public function testCheckParams()
58			{
59			DriverManager::getConnection([]);
60			}
61
62			/**
63			* @expectedException \Doctrine\DBAL\DBALException
64			*/
65			public function testInvalidDriver()
66			{
67			DriverManager::getConnection(['driver' => 'invalid_driver']);
68			}
69
70			/**
71			* @requires extension pdo_sqlite
72			*/
73			public function testCustomPlatform()
74			{
75			$mockPlatform = new MockPlatform();
76			$options = [
77			'pdo' => new \PDO('sqlite::memory:'),
78			'platform' => $mockPlatform,
79			];
80
81			$conn = DriverManager::getConnection($options);
82			self::assertSame($mockPlatform, $conn->getDatabasePlatform());
83			}
84
85			/**
86			* @requires extension pdo_sqlite
87			*/
88			public function testCustomWrapper()
89			{
90			$wrapperClass = ConnectionMock::class;
91
92			$options = [
93			'pdo' => new \PDO('sqlite::memory:'),
94			'wrapperClass' => $wrapperClass,
95			];
96
97			$conn = DriverManager::getConnection($options);
98			self::assertInstanceOf($wrapperClass, $conn);
99			}
100
101			/**
102			* @requires extension pdo_sqlite
103			*/
104			public function testInvalidWrapperClass()
105			{
106			$this->expectException(DBALException::class);
107
108			$options = [
109			'pdo' => new \PDO('sqlite::memory:'),
110			'wrapperClass' => stdClass::class,
111			];
112
113			DriverManager::getConnection($options);
114			}
115
116			public function testInvalidDriverClass()
117			{
118			$this->expectException(DBALException::class);
119
120			$options = ['driverClass' => stdClass::class];
121
122			DriverManager::getConnection($options);
123			}
124
125			public function testValidDriverClass()
126			{
127			$options = ['driverClass' => PDOMySQLDriver::class];
128
129			$conn = DriverManager::getConnection($options);
130			self::assertInstanceOf(PDOMySQLDriver::class, $conn->getDriver());
131			}
132
133			/**
134			* @dataProvider databaseUrls
135			*/
136			public function testDatabaseUrl($url, $expected)
137			{
138			$options = is_array($url) ? $url : ['url' => $url];
139
140			if (isset($options['pdo'])) {
141			if (! extension_loaded('pdo')) {
142			$this->markTestSkipped('PDO is not installed');
143			}
144
145			$options['pdo'] = $this->createMock(\PDO::class);
146			}
147
148			$options = is_array($url) ? $url : ['url' => $url];
149
150			if ($expected === false) {
151			$this->expectException(DBALException::class);
152			}
153
154			$conn = DriverManager::getConnection($options);
155
156			$params = $conn->getParams();
157			foreach ($expected as $key => $value) {
158			if (in_array($key, ['pdo', 'driver', 'driverClass'], true)) {
159			self::assertInstanceOf($value, $conn->getDriver());
160			} else {
161			self::assertEquals($value, $params[$key]);
162			}
163			}
164			}
165
166			public function databaseUrls()
167			{
168			return [
169			'simple URL' => [
170			'mysql://foo:bar@localhost/baz',
171			[
172			'user' => 'foo',
173			'password' => 'bar',
174			'host' => 'localhost',
175			'dbname' => 'baz',
176			'driver' => PDOMySQLDriver::class,
177			],
178			],
179			'simple URL with port' => [
180			'mysql://foo:bar@localhost:11211/baz',
181			[
182			'user' => 'foo',
183			'password' => 'bar',
184			'host' => 'localhost',
185			'port' => 11211,
186			'dbname' => 'baz',
187			'driver' => PDOMySQLDriver::class,
188			],
189			],
190			'sqlite relative URL with host' => [
191			'sqlite://localhost/foo/dbname.sqlite',
192			[
193			'path' => 'foo/dbname.sqlite',
194			'driver' => PDOSqliteDriver::class,
195			],
196			],
197			'sqlite absolute URL with host' => [
198			'sqlite://localhost//tmp/dbname.sqlite',
199			[
200			'path' => '/tmp/dbname.sqlite',
201			'driver' => PDOSqliteDriver::class,
202			],
203			],
204			'sqlite relative URL without host' => [
205			'sqlite:///foo/dbname.sqlite',
206			[
207			'path' => 'foo/dbname.sqlite',
208			'driver' => PDOSqliteDriver::class,
209			],
210			],
211			'sqlite absolute URL without host' => [
212			'sqlite:////tmp/dbname.sqlite',
213			[
214			'path' => '/tmp/dbname.sqlite',
215			'driver' => PDOSqliteDriver::class,
216			],
217			],
218			'sqlite memory' => [
219			'sqlite:///:memory:',
220			[
221			'memory' => true,
222			'driver' => PDOSqliteDriver::class,
223			],
224			],
225			'sqlite memory with host' => [
226			'sqlite://localhost/:memory:',
227			[
228			'memory' => true,
229			'driver' => PDOSqliteDriver::class,
230			],
231			],
232			'params parsed from URL override individual params' => [
233			[
234			'url' => 'mysql://foo:bar@localhost/baz',
235			'password' => 'lulz',
236			],
237			[
238			'user' => 'foo',
239			'password' => 'bar',
240			'host' => 'localhost',
241			'dbname' => 'baz',
242			'driver' => PDOMySQLDriver::class,
243			],
244			],
245			'params not parsed from URL but individual params are preserved' => [
246			[
247			'url' => 'mysql://foo:bar@localhost/baz',
248			'port' => 1234,
249			],
250			[
251			'user' => 'foo',
252			'password' => 'bar',
253			'host' => 'localhost',
254			'port' => 1234,
255			'dbname' => 'baz',
256			'driver' => PDOMySQLDriver::class,
257			],
258			],
259			'query params from URL are used as extra params' => [
260			'url' => 'mysql://foo:bar@localhost/dbname?charset=UTF-8',
261			['charset' => 'UTF-8'],
262			],
263			'simple URL with fallthrough scheme not defined in map' => [
264			'sqlsrv://foo:bar@localhost/baz',
265			[
266			'user' => 'foo',
267			'password' => 'bar',
268			'host' => 'localhost',
269			'dbname' => 'baz',
270			'driver' => SQLSrvDriver::class,
271			],
272			],
273			'simple URL with fallthrough scheme containing underscores fails' => [
274			'drizzle_pdo_mysql://foo:bar@localhost/baz',
275			false,
276			],
277			'simple URL with fallthrough scheme containing dashes works' => [
278			'drizzle-pdo-mysql://foo:bar@localhost/baz',
279			[
280			'user' => 'foo',
281			'password' => 'bar',
282			'host' => 'localhost',
283			'dbname' => 'baz',
284			'driver' => DrizzlePDOMySqlDriver::class,
285			],
286			],
287			'simple URL with percent encoding' => [
288			'mysql://foo%3A:bar%2F@localhost/baz+baz%40',
289			[
290			'user' => 'foo:',
291			'password' => 'bar/',
292			'host' => 'localhost',
293			'dbname' => 'baz+baz@',
294			'driver' => PDOMySQLDriver::class,
295			],
296			],
297			'simple URL with percent sign in password' => [
298			'mysql://foo:bar%25bar@localhost/baz',
299			[
300			'user' => 'foo',
301			'password' => 'bar%bar',
302			'host' => 'localhost',
303			'dbname' => 'baz',
304			'driver' => PDOMySQLDriver::class,
305			],
306			],
307
308			// DBAL-1234
309			'URL without scheme and without any driver information' => [
310			['url' => '//foo:bar@localhost/baz'],
311			false,
312			],
313			'URL without scheme but default PDO driver' => [
314			[
315			'url' => '//foo:bar@localhost/baz',
316			'pdo' => true,
317			],
318			false,
319			],
320			'URL without scheme but default driver' => [
321			[
322			'url' => '//foo:bar@localhost/baz',
323			'driver' => 'pdo_mysql',
324			],
325			[
326			'user' => 'foo',
327			'password' => 'bar',
328			'host' => 'localhost',
329			'dbname' => 'baz',
330			'driver' => PDOMySQLDriver::class,
331			],
332			],
333			'URL without scheme but custom driver' => [
334			[
335			'url' => '//foo:bar@localhost/baz',
336			'driverClass' => DriverMock::class,
337			],
338			[
339			'user' => 'foo',
340			'password' => 'bar',
341			'host' => 'localhost',
342			'dbname' => 'baz',
343			'driverClass' => DriverMock::class,
344			],
345			],
346			'URL without scheme but default PDO driver and default driver' => [
347			[
348			'url' => '//foo:bar@localhost/baz',
349			'pdo' => true,
350			'driver' => 'pdo_mysql',
351			],
352			[
353			'user' => 'foo',
354			'password' => 'bar',
355			'host' => 'localhost',
356			'dbname' => 'baz',
357			'driver' => PDOMySQLDriver::class,
358			],
359			],
360			'URL without scheme but driver and custom driver' => [
361			[
362			'url' => '//foo:bar@localhost/baz',
363			'driver' => 'pdo_mysql',
364			'driverClass' => DriverMock::class,
365			],
366			[
367			'user' => 'foo',
368			'password' => 'bar',
369			'host' => 'localhost',
370			'dbname' => 'baz',
371			'driverClass' => DriverMock::class,
372			],
373			],
374			'URL with default PDO driver' => [
375			[
376			'url' => 'mysql://foo:bar@localhost/baz',
377			'pdo' => true,
378			],
379			[
380			'user' => 'foo',
381			'password' => 'bar',
382			'host' => 'localhost',
383			'dbname' => 'baz',
384			'driver' => PDOMySQLDriver::class,
385			],
386			],
387			'URL with default driver' => [
388			[
389			'url' => 'mysql://foo:bar@localhost/baz',
390			'driver' => 'sqlite',
391			],
392			[
393			'user' => 'foo',
394			'password' => 'bar',
395			'host' => 'localhost',
396			'dbname' => 'baz',
397			'driver' => PDOMySQLDriver::class,
398			],
399			],
400			'URL with default custom driver' => [
401			[
402			'url' => 'mysql://foo:bar@localhost/baz',
403			'driverClass' => DriverMock::class,
404			],
405			[
406			'user' => 'foo',
407			'password' => 'bar',
408			'host' => 'localhost',
409			'dbname' => 'baz',
410			'driver' => PDOMySQLDriver::class,
411			],
412			],
413			'URL with default PDO driver and default driver' => [
414			[
415			'url' => 'mysql://foo:bar@localhost/baz',
416			'pdo' => true,
417			'driver' => 'sqlite',
418			],
419			[
420			'user' => 'foo',
421			'password' => 'bar',
422			'host' => 'localhost',
423			'dbname' => 'baz',
424			'driver' => PDOMySQLDriver::class,
425			],
426			],
427			'URL with default driver and default custom driver' => [
428			[
429			'url' => 'mysql://foo:bar@localhost/baz',
430			'driver' => 'sqlite',
431			'driverClass' => DriverMock::class,
432			],
433			[
434			'user' => 'foo',
435			'password' => 'bar',
436			'host' => 'localhost',
437			'dbname' => 'baz',
438			'driver' => PDOMySQLDriver::class,
439			],
440			],
441			'URL with default PDO driver and default driver and default custom driver' => [
442			[
443			'url' => 'mysql://foo:bar@localhost/baz',
444			'pdo' => true,
445			'driver' => 'sqlite',
446			'driverClass' => DriverMock::class,
447			],
448			[
449			'user' => 'foo',
450			'password' => 'bar',
451			'host' => 'localhost',
452			'dbname' => 'baz',
453			'driver' => PDOMySQLDriver::class,
454			],
455			],
456			];
457			}
458			}
459

doctrine / dbal

Pull Request — master (#2996)

DriverManagerTest::testInvalidWrapperClass() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like