PDOTest::testQuoteInvalidType() - Code Metrics - Inspection of "fix scrutinizer issues (all solvable ;)" - crate/crate-pdo - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#6)

by Christian

created 2017-01-31 08:42 UTC

PDOTest::testQuoteInvalidType() A

↳ Parent: PDOTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php
/**
 * Licensed to CRATE Technology GmbH("Crate") under one or more contributor
 * license agreements.  See the NOTICE file distributed with this work for
 * additional information regarding copyright ownership.  Crate licenses
 * this file to you under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.  You may
 * obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
 * License for the specific language governing permissions and limitations
 * under the License.
 *
 * However, if you have executed another commercial license agreement
 * with Crate these terms will supersede the license and you may use the
 * software solely pursuant to the terms of the relevant commercial agreement.
 */

namespace CrateTest\PDO;

use Crate\PDO\Exception\InvalidArgumentException;
use Crate\PDO\Exception\PDOException;
use Crate\PDO\Exception\UnsupportedException;
use Crate\PDO\Http\Client;
use Crate\PDO\Http\ClientInterface;
use Crate\PDO\PDO;
use Crate\PDO\PDOStatement;
use PHPUnit_Framework_TestCase;
use ReflectionClass;

/**
 * Tests for {@see \Crate\PDO\PDO}
 *
 * @coversDefaultClass \Crate\PDO\PDO
 * @covers ::<!public>
 *
 * @group unit
 */
class PDOTest extends PHPUnit_Framework_TestCase
{
    /**
     * @var PDO
     */
    protected $pdo;

    /**
     * @var \PHPUnit_Framework_MockObject_MockObject
     */
    protected $client;

    protected function setUp()
    {
        $this->client = $this->getMockBuilder(Client::class)
            ->disableOriginalConstructor()
            ->getMock();

        $this->pdo = new PDO('crate:localhost:1234', null, null, []);

        $reflection = new ReflectionClass(PDO::class);

        $property = $reflection->getProperty('client');
        $property->setAccessible(true);
        $property->setValue($this->pdo, $this->client);
    }

    /**
     * @covers ::__construct
     */
    public function testInstantiation()
    {
        $pdo = new PDO('crate:localhost:1234', null, null, []);

        $this->assertInstanceOf('Crate\PDO\PDO', $pdo);
        $this->assertInstanceOf('PDO', $pdo);
    }

    public function testInstantiationWithDefaultSchema()
    {
        $pdo = new PDO('crate:localhost:1234/my_schema', null, null, []);

        $this->assertInstanceOf('Crate\PDO\PDO', $pdo);
        $this->assertInstanceOf('PDO', $pdo);
    }

    /**
     * @covers ::__construct
     */
    public function testInstantiationWithTraversableOptions()
    {
        $pdo = new PDO('crate:localhost:1234', null, null, new \ArrayObject([PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION]));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $this->assertEquals(PDO::ERRMODE_EXCEPTION, $pdo->getAttribute(PDO::ATTR_ERRMODE));
    }

    /**
     * @covers ::__construct
     */
    public function testInstantiationWithInvalidOptions()
    {
        $this->setExpectedException('Crate\Stdlib\Exception\InvalidArgumentException');

        new PDO('crate:localhost:1234', null, null, 'a invalid value');
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * @covers ::__construct
     */
    public function testInstantiationWithHttpAuth() {
        $user = 'crate';
        $passwd = 'secret';
        $pdo = new PDO('crate:localhost:44200', $user, $passwd, []);
        $this->assertEquals([$user, $passwd], $pdo->getAttribute(PDO::CRATE_ATTR_HTTP_BASIC_AUTH));
    }

    /**
     * @covers ::setAttribute
     */
    public function testSetAttributeWithHttpBasicAuth()
    {
        $user = 'crate';
        $passwd = 'secret';
        $expectedCredentials = [$user, $passwd];

        $client = $this->getMock(ClientInterface::class);
        $pdo = new PDO('crate:localhost:44200', null, null, []);
        $reflection = new ReflectionClass(PDO::class);
        $property = $reflection->getProperty('client');
        $property->setAccessible(true);
        $property->setValue($pdo, $client);
        $client
            ->expects($this->once())
            ->method('setHttpBasicAuth')
            ->with($user, $passwd);

        $pdo->setAttribute(PDO::CRATE_ATTR_HTTP_BASIC_AUTH, [$user, $passwd]);
        $this->assertEquals($expectedCredentials, $pdo->getAttribute(PDO::CRATE_ATTR_HTTP_BASIC_AUTH));
    }

    /**
     * @covers ::setAttribute
     */
    public function testSetAttributeWithDefaultSchema()
    {
        $client = $this->getMockBuilder(Client::class)
            ->disableOriginalConstructor()
            ->getMock();
        $pdo = new PDO('crate:localhost:44200/my_schema', null, null, []);
        $reflection = new ReflectionClass(PDO::class);
        $property = $reflection->getProperty('client');
        $property->setAccessible(true);
        $property->setValue($pdo, $client);
        $client->expects($this->once())
            ->method('setDefaultSchema')
            ->with('my_schema');

        $pdo->setAttribute(PDO::CRATE_ATTR_DEFAULT_SCHEMA, 'my_schema');
        $this->assertEquals('my_schema', $pdo->getAttribute(PDO::CRATE_ATTR_DEFAULT_SCHEMA));
    }

    /**
     * @covers ::getAttribute
     */
    public function testGetAttributeWithInvalidAttribute()
    {
        $this->setExpectedException(PDOException::class);
        $this->pdo->getAttribute('I DONT EXIST');
    }

    /**
     * @covers ::setAttribute
     */
    public function testSetAttributeWithInvalidAttribute()
    {
        $this->setExpectedException(PDOException::class);
        $this->pdo->setAttribute('I DONT EXIST', 'value');
    }

    /**
     * @covers ::getAttribute
     * @covers ::setAttribute
     */
    public function testGetAndSetDefaultFetchMode()
    {
        $this->assertEquals(PDO::FETCH_BOTH, $this->pdo->getAttribute(PDO::ATTR_DEFAULT_FETCH_MODE));
        $this->pdo->setAttribute(PDO::ATTR_DEFAULT_FETCH_MODE, PDO::FETCH_ASSOC);
        $this->assertEquals(PDO::FETCH_ASSOC, $this->pdo->getAttribute(PDO::ATTR_DEFAULT_FETCH_MODE));
    }

    /**
     * @covers ::getAttribute
     * @covers ::setAttribute
     */
    public function testGetAndSetErrorMode()
    {
        $this->assertEquals(PDO::ERRMODE_SILENT, $this->pdo->getAttribute(PDO::ATTR_ERRMODE));
        $this->pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
        $this->assertEquals(PDO::ERRMODE_EXCEPTION, $this->pdo->getAttribute(PDO::ATTR_ERRMODE));
    }

    /**
     * @covers ::getAttribute
     */
    public function testGetVersion()
    {
        $this->assertEquals(PDO::VERSION, $this->pdo->getAttribute(PDO::ATTR_CLIENT_VERSION));
    }

    /**
     * @covers ::getAttribute
     */
    public function testGetDriverName()
    {
        $this->assertEquals(PDO::DRIVER_NAME, $this->pdo->getAttribute(PDO::ATTR_DRIVER_NAME));
    }

    public function testGetStatementClass()
    {
        $this->assertEquals([PDOStatement::class], $this->pdo->getAttribute(PDO::ATTR_STATEMENT_CLASS));
    }

    /**
     * @covers ::getAttribute
     */
    public function testPersistent()
    {
        $this->assertFalse($this->pdo->getAttribute(PDO::ATTR_PERSISTENT));
    }

    /**
     * @covers ::getAttribute
     */
    public function testPreFetch()
    {
        $this->assertFalse($this->pdo->getAttribute(PDO::ATTR_PREFETCH));
    }

    /**
     * @covers ::getAttribute
     */
    public function testAutoCommit()
    {
        $this->assertTrue($this->pdo->getAttribute(PDO::ATTR_AUTOCOMMIT));
    }

    /**
     * @covers ::getAttribute
     * @covers ::setAttribute
     */
    public function testGetAndSetTimeout()
    {
        $timeout = 3;

        $this->client
            ->expects($this->once())
            ->method('setTimeout')
            ->with($timeout);

        $this->assertEquals(5, $this->pdo->getAttribute(PDO::ATTR_TIMEOUT));

        $this->pdo->setAttribute(PDO::ATTR_TIMEOUT, $timeout);

        $this->assertEquals($timeout, $this->pdo->getAttribute(PDO::ATTR_TIMEOUT));
    }

    /**
     * @covers ::quote
     */
    public function testQuote()
    {
        $this->setExpectedException('Crate\PDO\Exception\UnsupportedException');
        $this->pdo->quote('helloWorld', PDO::PARAM_STR);
    }

    /**
     * @covers ::quote
     */
    public function testQuoteUnsupportedType()
    {
        $this->setExpectedException('Crate\PDO\Exception\UnsupportedException');
        $this->pdo->quote('helloWorld', PDO::PARAM_LOB);
    }

    /**
     * @covers ::quote
     */
    public function testQuoteInvalidType()
    {
        $this->setExpectedException('Crate\PDO\Exception\InvalidArgumentException');
        $this->pdo->quote('helloWorld', 100);
    }

    /**
     * @return array
     */
    public function quoteExceptionProvider()
    {
        return [
            [PDO::PARAM_LOB, PDOException::class, 'This is not supported by crate.io'],
            [PDO::PARAM_STR, PDOException::class, 'This is not supported, please use prepared statements.'],
            [120, InvalidArgumentException::class, 'Unknown param type'],
        ];
    }

    /**
     * @dataProvider quoteExceptionProvider
     * @covers ::quote
     *
     * @param int $paramType
     * @param string $message
     */
    public function testQuoteWithExpectedException($paramType, $exception, $message)
    {
        $this->setExpectedException($exception, $message);
        $this->pdo->quote('helloWorld', $paramType);
    }

    /**
     * @covers ::prepare
     */
    public function testPrepareReturnsAPDOStatement()
    {
        $statement = $this->pdo->prepare('SELECT * FROM tweets');
        $this->assertInstanceOf(PDOStatement::class, $statement);
    }

    /**
     * @covers ::getAvailableDrivers
     */
    public function testAvailableDriversContainsCrate()
    {
        $this->assertContains('crate', PDO::getAvailableDrivers());
    }

    /**
     * @covers ::beginTransaction
     */
    public function testBeginTransactionThrowsUnsupportedException()
    {
        $this->assertTrue($this->pdo->beginTransaction());
    }

    /**
     * @covers ::commit
     */
    public function testCommitThrowsUnsupportedException()
    {
        $this->assertTrue($this->pdo->commit());
    }

    /**
     * @covers ::rollback
     */
    public function testRollbackThrowsUnsupportedException()
    {
        $this->setExpectedException(UnsupportedException::class);
        $this->pdo->rollBack();
    }

    /**
     * @covers ::inTransaction
     */
    public function testInTransactionThrowsUnsupportedException()
    {
        $this->assertFalse($this->pdo->inTransaction());
    }

    /**
     * @covers ::lastInsertId
     */
    public function testLastInsertIdThrowsUnsupportedException()
    {
        $this->setExpectedException(UnsupportedException::class);
        $this->pdo->lastInsertId();
    }
}


1			<?php
2			/**
3			* Licensed to CRATE Technology GmbH("Crate") under one or more contributor
4			* license agreements. See the NOTICE file distributed with this work for
5			* additional information regarding copyright ownership. Crate licenses
6			* this file to you under the Apache License, Version 2.0 (the "License");
7			* you may not use this file except in compliance with the License. You may
8			* obtain a copy of the License at
9			*
10			* http://www.apache.org/licenses/LICENSE-2.0
11			*
12			* Unless required by applicable law or agreed to in writing, software
13			* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
14			* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
15			* License for the specific language governing permissions and limitations
16			* under the License.
17			*
18			* However, if you have executed another commercial license agreement
19			* with Crate these terms will supersede the license and you may use the
20			* software solely pursuant to the terms of the relevant commercial agreement.
21			*/
22
23			namespace CrateTest\PDO;
24
25			use Crate\PDO\Exception\InvalidArgumentException;
26			use Crate\PDO\Exception\PDOException;
27			use Crate\PDO\Exception\UnsupportedException;
28			use Crate\PDO\Http\Client;
29			use Crate\PDO\Http\ClientInterface;
30			use Crate\PDO\PDO;
31			use Crate\PDO\PDOStatement;
32			use PHPUnit_Framework_TestCase;
33			use ReflectionClass;
34
35			/**
36			* Tests for {@see \Crate\PDO\PDO}
37			*
38			* @coversDefaultClass \Crate\PDO\PDO
39			* @covers ::<!public>
40			*
41			* @group unit
42			*/
43			class PDOTest extends PHPUnit_Framework_TestCase
44			{
45			/**
46			* @var PDO
47			*/
48			protected $pdo;
49
50			/**
51			* @var \PHPUnit_Framework_MockObject_MockObject
52			*/
53			protected $client;
54
55			protected function setUp()
56			{
57			$this->client = $this->getMockBuilder(Client::class)
58			->disableOriginalConstructor()
59			->getMock();
60
61			$this->pdo = new PDO('crate:localhost:1234', null, null, []);
62
63			$reflection = new ReflectionClass(PDO::class);
64
65			$property = $reflection->getProperty('client');
66			$property->setAccessible(true);
67			$property->setValue($this->pdo, $this->client);
68			}
69
70			/**
71			* @covers ::__construct
72			*/
73			public function testInstantiation()
74			{
75			$pdo = new PDO('crate:localhost:1234', null, null, []);
76
77			$this->assertInstanceOf('Crate\PDO\PDO', $pdo);
78			$this->assertInstanceOf('PDO', $pdo);
79			}
80
81			public function testInstantiationWithDefaultSchema()
82			{
83			$pdo = new PDO('crate:localhost:1234/my_schema', null, null, []);
84
85			$this->assertInstanceOf('Crate\PDO\PDO', $pdo);
86			$this->assertInstanceOf('PDO', $pdo);
87			}
88
89			/**
90			* @covers ::__construct
91			*/
92			public function testInstantiationWithTraversableOptions()
93			{
94			$pdo = new PDO('crate:localhost:1234', null, null, new \ArrayObject([PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION]));
			0 ignored issues – show Documentation introduced 2015-12-07 07:15 UTC by Report Bug Copy Issue Report `new \ArrayObject(array(\...DO::ERRMODE_EXCEPTION))` is of type `object<ArrayObject>`, but the function expects a `null\|array`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
95			$this->assertEquals(PDO::ERRMODE_EXCEPTION, $pdo->getAttribute(PDO::ATTR_ERRMODE));
96			}
97
98			/**
99			* @covers ::__construct
100			*/
101			public function testInstantiationWithInvalidOptions()
102			{
103			$this->setExpectedException('Crate\Stdlib\Exception\InvalidArgumentException');
104
105			new PDO('crate:localhost:1234', null, null, 'a invalid value');
			0 ignored issues – show Documentation introduced 2015-12-07 07:15 UTC by Report Bug Copy Issue Report `'a invalid value'` is of type `string`, but the function expects a `null\|array`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
106			}
107
108			/**
109			* @covers ::__construct
110			*/
111			public function testInstantiationWithHttpAuth() {
112			$user = 'crate';
113			$passwd = 'secret';
114			$pdo = new PDO('crate:localhost:44200', $user, $passwd, []);
115			$this->assertEquals([$user, $passwd], $pdo->getAttribute(PDO::CRATE_ATTR_HTTP_BASIC_AUTH));
116			}
117
118			/**
119			* @covers ::setAttribute
120			*/
121			public function testSetAttributeWithHttpBasicAuth()
122			{
123			$user = 'crate';
124			$passwd = 'secret';
125			$expectedCredentials = [$user, $passwd];
126
127			$client = $this->getMock(ClientInterface::class);
128			$pdo = new PDO('crate:localhost:44200', null, null, []);
129			$reflection = new ReflectionClass(PDO::class);
130			$property = $reflection->getProperty('client');
131			$property->setAccessible(true);
132			$property->setValue($pdo, $client);
133			$client
134			->expects($this->once())
135			->method('setHttpBasicAuth')
136			->with($user, $passwd);
137
138			$pdo->setAttribute(PDO::CRATE_ATTR_HTTP_BASIC_AUTH, [$user, $passwd]);
139			$this->assertEquals($expectedCredentials, $pdo->getAttribute(PDO::CRATE_ATTR_HTTP_BASIC_AUTH));
140			}
141
142			/**
143			* @covers ::setAttribute
144			*/
145			public function testSetAttributeWithDefaultSchema()
146			{
147			$client = $this->getMockBuilder(Client::class)
148			->disableOriginalConstructor()
149			->getMock();
150			$pdo = new PDO('crate:localhost:44200/my_schema', null, null, []);
151			$reflection = new ReflectionClass(PDO::class);
152			$property = $reflection->getProperty('client');
153			$property->setAccessible(true);
154			$property->setValue($pdo, $client);
155			$client->expects($this->once())
156			->method('setDefaultSchema')
157			->with('my_schema');
158
159			$pdo->setAttribute(PDO::CRATE_ATTR_DEFAULT_SCHEMA, 'my_schema');
160			$this->assertEquals('my_schema', $pdo->getAttribute(PDO::CRATE_ATTR_DEFAULT_SCHEMA));
161			}
162
163			/**
164			* @covers ::getAttribute
165			*/
166			public function testGetAttributeWithInvalidAttribute()
167			{
168			$this->setExpectedException(PDOException::class);
169			$this->pdo->getAttribute('I DONT EXIST');
170			}
171
172			/**
173			* @covers ::setAttribute
174			*/
175			public function testSetAttributeWithInvalidAttribute()
176			{
177			$this->setExpectedException(PDOException::class);
178			$this->pdo->setAttribute('I DONT EXIST', 'value');
179			}
180
181			/**
182			* @covers ::getAttribute
183			* @covers ::setAttribute
184			*/
185			public function testGetAndSetDefaultFetchMode()
186			{
187			$this->assertEquals(PDO::FETCH_BOTH, $this->pdo->getAttribute(PDO::ATTR_DEFAULT_FETCH_MODE));
188			$this->pdo->setAttribute(PDO::ATTR_DEFAULT_FETCH_MODE, PDO::FETCH_ASSOC);
189			$this->assertEquals(PDO::FETCH_ASSOC, $this->pdo->getAttribute(PDO::ATTR_DEFAULT_FETCH_MODE));
190			}
191
192			/**
193			* @covers ::getAttribute
194			* @covers ::setAttribute
195			*/
196			public function testGetAndSetErrorMode()
197			{
198			$this->assertEquals(PDO::ERRMODE_SILENT, $this->pdo->getAttribute(PDO::ATTR_ERRMODE));
199			$this->pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
200			$this->assertEquals(PDO::ERRMODE_EXCEPTION, $this->pdo->getAttribute(PDO::ATTR_ERRMODE));
201			}
202
203			/**
204			* @covers ::getAttribute
205			*/
206			public function testGetVersion()
207			{
208			$this->assertEquals(PDO::VERSION, $this->pdo->getAttribute(PDO::ATTR_CLIENT_VERSION));
209			}
210
211			/**
212			* @covers ::getAttribute
213			*/
214			public function testGetDriverName()
215			{
216			$this->assertEquals(PDO::DRIVER_NAME, $this->pdo->getAttribute(PDO::ATTR_DRIVER_NAME));
217			}
218
219			public function testGetStatementClass()
220			{
221			$this->assertEquals([PDOStatement::class], $this->pdo->getAttribute(PDO::ATTR_STATEMENT_CLASS));
222			}
223
224			/**
225			* @covers ::getAttribute
226			*/
227			public function testPersistent()
228			{
229			$this->assertFalse($this->pdo->getAttribute(PDO::ATTR_PERSISTENT));
230			}
231
232			/**
233			* @covers ::getAttribute
234			*/
235			public function testPreFetch()
236			{
237			$this->assertFalse($this->pdo->getAttribute(PDO::ATTR_PREFETCH));
238			}
239
240			/**
241			* @covers ::getAttribute
242			*/
243			public function testAutoCommit()
244			{
245			$this->assertTrue($this->pdo->getAttribute(PDO::ATTR_AUTOCOMMIT));
246			}
247
248			/**
249			* @covers ::getAttribute
250			* @covers ::setAttribute
251			*/
252			public function testGetAndSetTimeout()
253			{
254			$timeout = 3;
255
256			$this->client
257			->expects($this->once())
258			->method('setTimeout')
259			->with($timeout);
260
261			$this->assertEquals(5, $this->pdo->getAttribute(PDO::ATTR_TIMEOUT));
262
263			$this->pdo->setAttribute(PDO::ATTR_TIMEOUT, $timeout);
264
265			$this->assertEquals($timeout, $this->pdo->getAttribute(PDO::ATTR_TIMEOUT));
266			}
267
268			/**
269			* @covers ::quote
270			*/
271			public function testQuote()
272			{
273			$this->setExpectedException('Crate\PDO\Exception\UnsupportedException');
274			$this->pdo->quote('helloWorld', PDO::PARAM_STR);
275			}
276
277			/**
278			* @covers ::quote
279			*/
280			public function testQuoteUnsupportedType()
281			{
282			$this->setExpectedException('Crate\PDO\Exception\UnsupportedException');
283			$this->pdo->quote('helloWorld', PDO::PARAM_LOB);
284			}
285
286			/**
287			* @covers ::quote
288			*/
289			public function testQuoteInvalidType()
290			{
291			$this->setExpectedException('Crate\PDO\Exception\InvalidArgumentException');
292			$this->pdo->quote('helloWorld', 100);
293			}
294
295			/**
296			* @return array
297			*/
298			public function quoteExceptionProvider()
299			{
300			return [
301			[PDO::PARAM_LOB, PDOException::class, 'This is not supported by crate.io'],
302			[PDO::PARAM_STR, PDOException::class, 'This is not supported, please use prepared statements.'],
303			[120, InvalidArgumentException::class, 'Unknown param type'],
304			];
305			}
306
307			/**
308			* @dataProvider quoteExceptionProvider
309			* @covers ::quote
310			*
311			* @param int $paramType
312			* @param string $message
313			*/
314			public function testQuoteWithExpectedException($paramType, $exception, $message)
315			{
316			$this->setExpectedException($exception, $message);
317			$this->pdo->quote('helloWorld', $paramType);
318			}
319
320			/**
321			* @covers ::prepare
322			*/
323			public function testPrepareReturnsAPDOStatement()
324			{
325			$statement = $this->pdo->prepare('SELECT * FROM tweets');
326			$this->assertInstanceOf(PDOStatement::class, $statement);
327			}
328
329			/**
330			* @covers ::getAvailableDrivers
331			*/
332			public function testAvailableDriversContainsCrate()
333			{
334			$this->assertContains('crate', PDO::getAvailableDrivers());
335			}
336
337			/**
338			* @covers ::beginTransaction
339			*/
340			public function testBeginTransactionThrowsUnsupportedException()
341			{
342			$this->assertTrue($this->pdo->beginTransaction());
343			}
344
345			/**
346			* @covers ::commit
347			*/
348			public function testCommitThrowsUnsupportedException()
349			{
350			$this->assertTrue($this->pdo->commit());
351			}
352
353			/**
354			* @covers ::rollback
355			*/
356			public function testRollbackThrowsUnsupportedException()
357			{
358			$this->setExpectedException(UnsupportedException::class);
359			$this->pdo->rollBack();
360			}
361
362			/**
363			* @covers ::inTransaction
364			*/
365			public function testInTransactionThrowsUnsupportedException()
366			{
367			$this->assertFalse($this->pdo->inTransaction());
368			}
369
370			/**
371			* @covers ::lastInsertId
372			*/
373			public function testLastInsertIdThrowsUnsupportedException()
374			{
375			$this->setExpectedException(UnsupportedException::class);
376			$this->pdo->lastInsertId();
377			}
378			}
379

crate / crate-pdo

Pull Request — master (#6)

PDOTest::testQuoteInvalidType() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like