Yiisoft\Db\TestSupport\TestConnectionTrait

Complexity

Total Complexity

20

Size/Duplication

Total Lines	462
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	testCacheKey()	0	4	1
A	testNestedTransaction()	0	14	1
A	testTransactionShortcutException()	0	14	1
A	testTransactionShortcutCorrect()	0	16	1
A	testExceptionContainsRawQuery()	0	33	2
A	runExceptionTest()	0	36	3
A	testTransaction()	0	32	1
A	testRollbackTransactionsWithSavePoints()	0	29	1
A	testSerialize()	0	15	1
A	testPartialRollbackTransactionsWithSavePoints()	0	35	1
A	testCommitTransactionsWithSavepoints()	0	33	1
A	testNestedTransactionNotSupported()	0	10	1
B	testEnableQueryLog()	0	93	3
A	testOpenClose()	0	18	1
A	testClone()	0	34	1

<?php

declare(strict_types=1);

namespace Yiisoft\Db\TestSupport;

use PDO;
use Yiisoft\Db\Connection\ConnectionInterface;
use Yiisoft\Db\Driver\PDO\ConnectionPDOInterface;
use Yiisoft\Db\Exception\Exception;
use Yiisoft\Db\Exception\NotSupportedException;

use function PHPUnit\Framework\assertEquals;
use function serialize;
use function unserialize;

trait TestConnectionTrait
{
    public function testCacheKey(): void
    {
        $db = $this->getConnection();

It seems like getConnection() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $this->assertEquals([$this->dsn, $this->username], $db->getCacheKey());

It seems like assertEquals() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    public function testOpenClose(): void
    {
        $db = $this->getConnection();
        $this->assertFalse($db->isActive());

It seems like assertFalse() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $this->assertNull($db->getPDO());

It seems like assertNull() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $db->open();
        $this->assertTrue($db->isActive());

It seems like assertTrue() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $this->assertInstanceOf(PDO::class, $db->getPDO());

It seems like assertInstanceOf() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $db->close();
        $this->assertFalse($db->isActive());
        $this->assertNull($db->getPDO());

        $db = $this->getConnection(false, 'unknown::memory:');
        $this->expectException(Exception::class);

It seems like expectException() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $this->expectExceptionMessage('could not find driver');

It seems like expectExceptionMessage() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $db->open();
    }

    public function testSerialize(): void
    {
        $db = $this->getConnection();

        $db->open();

        $serialized = serialize($db);

        $this->assertNotNull($db->getPDO());

It seems like assertNotNull() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $unserialized = unserialize($serialized);

        $this->assertInstanceOf(ConnectionPDOInterface::class, $unserialized);
        $this->assertNull($unserialized->getPDO());
        $this->assertEquals(123, $unserialized->createCommand('SELECT 123')->queryScalar());
    }

    public function testTransaction(): void
    {
        $db = $this->getConnection(true);

        $this->assertNull($db->getTransaction());

        $transaction = $db->beginTransaction();

        $this->assertNotNull($db->getTransaction());
        $this->assertTrue($transaction->isActive());

        $db->createCommand()->insert('profile', ['description' => 'test transaction'])->execute();

        $transaction->rollBack();

        $this->assertFalse($transaction->isActive());
        $this->assertNull($db->getTransaction());
        $this->assertEquals(0, $db->createCommand(
            "SELECT COUNT(*) FROM {{profile}} WHERE [[description]] = 'test transaction'"
        )->queryScalar());

        $transaction = $db->beginTransaction();

        $db->createCommand()->insert('profile', ['description' => 'test transaction'])->execute();

        $transaction->commit();

        $this->assertFalse($transaction->isActive());
        $this->assertNull($db->getTransaction());
        $this->assertEquals(1, $db->createCommand(
            "SELECT COUNT(*) FROM {{profile}} WHERE [[description]] = 'test transaction'"
        )->queryScalar());
    }

    public function testRollbackTransactionsWithSavePoints(): void
    {
        $db = $this->getConnection(true);
        $db->open();

        $transaction = $db->beginTransaction();
        assertEquals(1, $transaction->getLevel());

        $db->createCommand()->insert('profile', ['description' => 'test transaction'])->execute();

        $transaction->begin();
        assertEquals(2, $transaction->getLevel());

        $db->createCommand()->insert('profile', ['description' => 'test transaction'])->execute();

        $transaction->rollBack();
        assertEquals(1, $transaction->getLevel());
        $this->assertTrue($transaction->isActive());

        $db->createCommand()->insert('profile', ['description' => 'test transaction'])->execute();

        $transaction->rollBack();
        assertEquals(0, $transaction->getLevel());

        $this->assertFalse($transaction->isActive());
        $this->assertNull($db->getTransaction());
        $this->assertEquals(0, $db->createCommand(
            "SELECT COUNT(*) FROM {{profile}} WHERE [[description]] = 'test transaction'"
        )->queryScalar());
    }

    public function testPartialRollbackTransactionsWithSavePoints(): void
    {
        $db = $this->getConnection(true);
        $db->open();

        $transaction = $db->beginTransaction();
        assertEquals(1, $transaction->getLevel());

        $db->createCommand()->insert('profile', ['description' => 'test transaction1'])->execute();

        $transaction->begin();
        assertEquals(2, $transaction->getLevel());

        $db->createCommand()->insert('profile', ['description' => 'test transaction2'])->execute();

        $transaction->rollBack();
        assertEquals(1, $transaction->getLevel());
        $this->assertTrue($transaction->isActive());

        $db->createCommand()->insert('profile', ['description' => 'test transaction3'])->execute();

        $transaction->commit();
        assertEquals(0, $transaction->getLevel());

        $this->assertFalse($transaction->isActive());
        $this->assertNull($db->getTransaction());
        $this->assertEquals(1, $db->createCommand(
            "SELECT COUNT(*) FROM {{profile}} WHERE [[description]] = 'test transaction1'"
        )->queryScalar());
        $this->assertEquals(0, $db->createCommand(
            "SELECT COUNT(*) FROM {{profile}} WHERE [[description]] = 'test transaction2'"
        )->queryScalar());
        $this->assertEquals(1, $db->createCommand(
            "SELECT COUNT(*) FROM {{profile}} WHERE [[description]] = 'test transaction3'"
        )->queryScalar());
    }

    public function testCommitTransactionsWithSavepoints(): void
    {
        $db = $this->getConnection(true);

        $transaction = $db->beginTransaction();
        assertEquals(1, $transaction->getLevel());

        $db->createCommand()->insert('profile', ['description' => 'test transaction1'])->execute();

        $transaction->begin();
        assertEquals(2, $transaction->getLevel());

        $db->createCommand()->insert('profile', ['description' => 'test transaction2'])->execute();

        $transaction->commit();
        assertEquals(1, $transaction->getLevel());

        $db->createCommand()->insert('profile', ['description' => 'test transaction3'])->execute();

        $transaction->commit();
        assertEquals(0, $transaction->getLevel());

        $this->assertFalse($transaction->isActive());
        $this->assertNull($db->getTransaction());
        $this->assertEquals(1, $db->createCommand(
            "SELECT COUNT(*) FROM {{profile}} WHERE [[description]] = 'test transaction1'"
        )->queryScalar());
        $this->assertEquals(1, $db->createCommand(
            "SELECT COUNT(*) FROM {{profile}} WHERE [[description]] = 'test transaction2'"
        )->queryScalar());
        $this->assertEquals(1, $db->createCommand(
            "SELECT COUNT(*) FROM {{profile}} WHERE [[description]] = 'test transaction3'"
        )->queryScalar());
    }

    public function testTransactionShortcutException(): void
    {
        $db = $this->getConnection(true);

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

        $db->transaction(function () use ($db) {
            $db->createCommand()->insert('profile', ['description' => 'test transaction shortcut'])->execute();
            throw new Exception('Exception in transaction shortcut');
        });
        $profilesCount = $db->createCommand(
            "SELECT COUNT(*) FROM {{profile}} WHERE [[description]] = 'test transaction shortcut'"
        )->queryScalar();
        $this->assertEquals(0, $profilesCount, 'profile should not be inserted in transaction shortcut');
    }

    public function testTransactionShortcutCorrect(): void
    {
        $db = $this->getConnection(true);

        $result = $db->transaction(static function () use ($db) {
            $db->createCommand()->insert('profile', ['description' => 'test transaction shortcut'])->execute();
            return true;
        });

        $this->assertTrue($result, 'transaction shortcut valid value should be returned from callback');

        $profilesCount = $db->createCommand(
            "SELECT COUNT(*) FROM {{profile}} WHERE [[description]] = 'test transaction shortcut'"
        )->queryScalar();

        $this->assertEquals(1, $profilesCount, 'profile should be inserted in transaction shortcut');
    }

    /**
     * Tests nested transactions with partial rollback.
     *
     * {@see https://github.com/yiisoft/yii2/issues/9851}
     */
    public function testNestedTransaction(): void
    {
        $db = $this->getConnection();

        $db->transaction(function (ConnectionInterface $db) {
            $this->assertNotNull($db->getTransaction());

            $db->transaction(function (ConnectionInterface $db) {
                $transaction = $db->getTransaction();
                $this->assertNotNull($transaction);
                $transaction->rollBack();
            });

            $this->assertNotNull($db->getTransaction());
        });
    }

    public function testNestedTransactionNotSupported(): void
    {
        $db = $this->getConnection();

        $db->setEnableSavepoint(false);

        $db->transaction(function (ConnectionInterface $db) {
            $this->assertNotNull($db->getTransaction());
            $this->expectException(NotSupportedException::class);
            $db->beginTransaction();
        });
    }

    public function testEnableQueryLog(): void
    {
        $db = $this->getConnection();

        foreach (['qlog1', 'qlog2', 'qlog3', 'qlog4'] as $table) {
            if ($db->getTableSchema($table, true) !== null) {
                $db->createCommand()->dropTable($table)->execute();
            }
        }

        /* profiling and logging */
        $db->setLogger($this->logger);
        $db->setProfiler($this->profiler);

        $this->assertNotNull($this->logger);
        $this->assertNotNull($this->profiler);

        $this->logger->flush();
        $this->profiler->flush();

        $db->createCommand()->createTable('qlog1', ['id' => 'pk'])->execute();

        $this->assertCount(1, $this->getInaccessibleProperty($this->logger, 'messages'));

It seems like assertCount() must be provided by classes using this trait. How about adding it as abstract method to this trait?

It seems like getInaccessibleProperty() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $this->assertCount(1, $this->getInaccessibleProperty($this->profiler, 'messages'));
        $this->assertNotNull($db->getTableSchema('qlog1', true));

        $this->logger->flush();
        $this->profiler->flush();

        $db->createCommand('SELECT * FROM {{qlog1}}')->queryAll();

        $this->assertCount(1, $this->getInaccessibleProperty($this->logger, 'messages'));
        $this->assertCount(1, $this->getInaccessibleProperty($this->profiler, 'messages'));

        /* profiling only */
        $db->setLogger(null);
        $db->setProfiler($this->profiler);

        $this->logger->flush();
        $this->profiler->flush();

        $db->createCommand()->createTable('qlog2', ['id' => 'pk'])->execute();

        $this->assertCount(0, $this->getInaccessibleProperty($this->logger, 'messages'));
        $this->assertCount(1, $this->getInaccessibleProperty($this->profiler, 'messages'));
        $this->assertNotNull($db->getTableSchema('qlog2', true));

        $this->logger->flush();
        $this->profiler->flush();

        $db->createCommand('SELECT * FROM {{qlog2}}')->queryAll();

        $this->assertCount(0, $this->getInaccessibleProperty($this->logger, 'messages'));
        $this->assertCount(1, $this->getInaccessibleProperty($this->profiler, 'messages'));

        /* logging only */
        $db->setLogger($this->logger);
        $db->setProfiler(null);

        $this->logger->flush();
        $this->profiler->flush();

        $db->createCommand()->createTable('qlog3', ['id' => 'pk'])->execute();

        $this->assertCount(1, $this->getInaccessibleProperty($this->logger, 'messages'));
        $this->assertCount(0, $this->getInaccessibleProperty($this->profiler, 'messages'));
        $this->assertNotNull($db->getTableSchema('qlog3', true));

        $this->logger->flush();
        $this->profiler->flush();

        $db->createCommand('SELECT * FROM {{qlog3}}')->queryAll();

        $this->assertCount(1, $this->getInaccessibleProperty($this->logger, 'messages'));
        $this->assertCount(0, $this->getInaccessibleProperty($this->profiler, 'messages'));

        /* disabled */
        $db->setLogger(null);
        $db->setProfiler(null);

        $this->logger->flush();
        $this->profiler->flush();

        $db->createCommand()->createTable('qlog4', ['id' => 'pk'])->execute();

        $this->assertNotNull($db->getTableSchema('qlog4', true));
        $this->assertCount(0, $this->getInaccessibleProperty($this->logger, 'messages'));
        $this->assertCount(0, $this->getInaccessibleProperty($this->profiler, 'messages'));

        $db->createCommand('SELECT * FROM {{qlog4}}')->queryAll();

        $this->assertCount(0, $this->getInaccessibleProperty($this->logger, 'messages'));
        $this->assertCount(0, $this->getInaccessibleProperty($this->profiler, 'messages'));
    }

    public function testExceptionContainsRawQuery(): void
    {
        $db = $this->getConnection();

        if ($db->getTableSchema('qlog1', true) === null) {
            $db->createCommand()->createTable('qlog1', ['id' => 'pk'])->execute();
        }

        $db->setEmulatePrepare(true);

        /* profiling and logging */
        $db->setLogger($this->logger);
        $db->setProfiler($this->profiler);

        $this->runExceptionTest($db);

        /* profiling only */
        $db->setLogger(null);
        $db->setProfiler($this->profiler);

        $this->runExceptionTest($db);

        /* logging only */
        $db->setLogger($this->logger);
        $db->setProfiler(null);

        $this->runExceptionTest($db);

        /* disabled */
        $db->setLogger(null);
        $db->setProfiler(null);

        $this->runExceptionTest($db);
    }

    /**
     * @param ConnectionInterface $db
     */
    private function runExceptionTest(ConnectionInterface $db): void
    {
        $thrown = false;

        try {
            $db->createCommand('INSERT INTO qlog1(a) VALUES(:a);', [':a' => 1])->execute();
        } catch (Exception $e) {
            $this->assertStringContainsString(

It seems like assertStringContainsString() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                'INSERT INTO qlog1(a) VALUES(1);',
                $e->getMessage(),
                'Exceptions message should contain raw SQL query: ' . (string) $e
            );

            $thrown = true;
        }

        $this->assertTrue($thrown, 'An exception should have been thrown by the command.');

        $thrown = false;

        try {
            $db->createCommand(
                'SELECT * FROM qlog1 WHERE id=:a ORDER BY nonexistingcolumn;',
                [':a' => 1]
            )->queryAll();
        } catch (Exception $e) {
            $this->assertStringContainsString(
                'SELECT * FROM qlog1 WHERE id=1 ORDER BY nonexistingcolumn;',
                $e->getMessage(),
                'Exceptions message should contain raw SQL query: ' . (string) $e
            );

            $thrown = true;
        }

        $this->assertTrue($thrown, 'An exception should have been thrown by the command.');
    }

    /**
     * Ensure database connection is reset on when a connection is cloned.
     *
     * Make sure each connection element has its own PDO instance i.e. own connection to the DB.
     * Also transaction elements should not be shared between two connections.
     */
    public function testClone(): void
    {
        $db = $this->getConnection();

        $this->assertNull($db->getTransaction());
        $this->assertNull($db->getPDO());

        $db->open();

        $this->assertNull($db->getTransaction());
        $this->assertNotNull($db->getPDO());

        $conn2 = clone $db;

        $this->assertNull($db->getTransaction());
        $this->assertNotNull($db->getPDO());

        $this->assertNull($conn2->getTransaction());
        $this->assertNull($conn2->getPDO());

        $db->beginTransaction();

        $this->assertNotNull($db->getTransaction());
        $this->assertNotNull($db->getPDO());

        $this->assertNull($conn2->getTransaction());
        $this->assertNull($conn2->getPDO());

        $conn3 = clone $db;

        $this->assertNotNull($db->getTransaction());
        $this->assertNotNull($db->getPDO());
        $this->assertNull($conn3->getTransaction());
        $this->assertNull($conn3->getPDO());
    }
}