eZ\Publish\Core\Persistence\Legacy\Tests\TestCase

Complexity

Total Complexity

34

Size/Duplication

Total Lines	356
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	12

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	getDsn()	0	12	3
A	getDatabaseHandler()	0	9	2
A	getDatabaseConnection()	0	14	2
A	getSharedGateway()	0	16	2
A	setUp()	0	20	2
A	tearDown()	0	5	1
A	getResultTextRepresentation()	0	12	1
B	insertDatabaseFixture()	0	47	7
A	resetSequences()	0	14	3
A	assertQueryResult()	0	16	2
A	assertPropertiesCorrect()	0	15	3
A	assertStructsEqual()	0	16	3
A	getPublicPropertyNames()	0	11	1
A	getInstallationDir()	0	10	2

<?php

/**
 * File contains: eZ\Publish\Core\Persistence\Legacy\Tests\TestCase class.
 *
 * @copyright Copyright (C) eZ Systems AS. All rights reserved.
 * @license For full copyright and license information view LICENSE file distributed with this source code.
 */
namespace eZ\Publish\Core\Persistence\Legacy\Tests;

use Doctrine\Common\EventManager as DoctrineEventManager;
use Doctrine\DBAL\Connection;
use Doctrine\DBAL\ConnectionException;
use Doctrine\DBAL\DBALException;
use eZ\Publish\API\Repository\Tests\LegacySchemaImporter;
use eZ\Publish\Core\Persistence\Doctrine\ConnectionHandler;
use eZ\Publish\Core\Persistence\Database\SelectQuery;
use eZ\Publish\Core\Persistence\Legacy\SharedGateway;
use eZ\Publish\Core\Persistence\Tests\DatabaseConnectionFactory;
use EzSystems\DoctrineSchema\Database\DbPlatform\SqliteDbPlatform;
use PHPUnit\Framework\TestCase as BaseTestCase;
use InvalidArgumentException;
use ReflectionObject;
use PDOException;
use Exception;
use ReflectionProperty;

/**
 * Base test case for database related tests.
 */
abstract class TestCase extends BaseTestCase
{
    /**
     * DSN used for the DB backend.
     *
     * @var string
     */
    protected $dsn;

    /**
     * Name of the DB, extracted from DSN.
     *
     * @var string
     */
    protected $db;

    /**
     * Database handler -- to not be constructed twice for one test.
     *
     * @internal
     * @var \eZ\Publish\Core\Persistence\Database\DatabaseHandler
     */
    protected $handler;

    /**
     * Doctrine Database connection -- to not be constructed twice for one test.
     *
     * @internal
     * @var \Doctrine\DBAL\Connection
     */
    protected $connection;

    /** @var \eZ\Publish\Core\Persistence\Legacy\SharedGateway\Gateway */
    private $sharedGateway;

    /**
     * Get data source name.
     *
     * The database connection string is read from an optional environment
     * variable "DATABASE" and defaults to an in-memory SQLite database.
     *
     * @return string
     */
    protected function getDsn()
    {
        if (!$this->dsn) {
            $this->dsn = getenv('DATABASE');
            if (!$this->dsn) {
                $this->dsn = 'sqlite://:memory:';
            }
            $this->db = preg_replace('(^([a-z]+).*)', '\\1', $this->dsn);
        }

        return $this->dsn;
    }

    /**
     * Get a eZ Doctrine database connection handler.
     *
     * Get a ConnectionHandler, which can be used to interact with the configured
     * database. The database connection string is read from an optional
     * environment variable "DATABASE" and defaults to an in-memory SQLite
     * database.
     *
     * @return \eZ\Publish\Core\Persistence\Doctrine\ConnectionHandler
     */
    final public function getDatabaseHandler()
    {
        if (!$this->handler) {
            $this->handler = ConnectionHandler::createFromConnection($this->getDatabaseConnection());
            $this->db = $this->handler->getName();
        }

        return $this->handler;
    }

    /**
     * Get native Doctrine database connection.
     *
     * @throws \Doctrine\DBAL\DBALException
     */
    final public function getDatabaseConnection(): Connection
    {
        if (!$this->connection) {
            $eventManager = new DoctrineEventManager();
            $connectionFactory = new DatabaseConnectionFactory(
                [new SqliteDbPlatform()],
                $eventManager
            );

            $this->connection = $connectionFactory->createConnection($this->getDsn());
        }

        return $this->connection;
    }

    /**
     * @throws \Doctrine\DBAL\DBALException
     */
    final public function getSharedGateway(): SharedGateway\Gateway
    {
        if (!$this->sharedGateway) {
            $connection = $this->getDatabaseConnection();
            $factory = new SharedGateway\GatewayFactory(
                new SharedGateway\DatabasePlatform\FallbackGateway($connection),
                [
                    'sqlite' => new SharedGateway\DatabasePlatform\SqliteGateway($connection),
                ]
            );

            $this->sharedGateway = $factory->buildSharedGateway($connection);
        }

        return $this->sharedGateway;
    }

    /**
     * Resets the database on test setup, so we always operate on a clean
     * database.
     */
    protected function setUp(): void
    {
        try {
            $schemaImporter = new LegacySchemaImporter($this->getDatabaseConnection());
            $schemaImporter->importSchema(
                dirname(__DIR__, 5) .
                '/Bundle/EzPublishCoreBundle/Resources/config/storage/legacy/schema.yaml'
            );

            $this->resetSequences();
        } catch (PDOException | DBALException | ConnectionException $e) {
            self::fail(
                sprintf(
                    'PDO session could not be created: %s: %s',
                    get_class($e),
                    $e->getMessage()
                )
            );
        }
    }

    protected function tearDown(): void
    {
        unset($this->handler);
        unset($this->connection);
    }

    /**
     * Get a text representation of a result set.
     *
     * @param array $result
     *
     * @return string
     */
    protected static function getResultTextRepresentation(array $result)
    {
        return implode(
            "\n",
            array_map(
                function ($row) {
                    return implode(', ', $row);
                },
                $result
            )
        );
    }

    /**
     * Inserts database fixture from $file.
     *
     * @param string $file
     */
    protected function insertDatabaseFixture($file)
    {
        $data = require $file;
        $db = $this->getDatabaseHandler();

        foreach ($data as $table => $rows) {
            // Check that at least one row exists
            if (!isset($rows[0])) {
                continue;
            }

            $q = $db->createInsertQuery();
            $q->insertInto($db->quoteIdentifier($table));

            // Contains the bound parameters
            $values = [];

            // Binding the parameters
            foreach ($rows[0] as $col => $val) {
                $q->set(
                    $db->quoteIdentifier($col),
                    $q->bindParam($values[$col])
                );
            }

            $stmt = $q->prepare();

            foreach ($rows as $row) {
                try {
                    // This CANNOT be replaced by:
                    // $values = $row
                    // each $values[$col] is a PHP reference which should be
                    // kept for parameters binding to work
                    foreach ($row as $col => $val) {
                        $values[$col] = $val;
                    }

                    $stmt->execute();
                } catch (Exception $e) {
                    echo "$table ( ", implode(', ', $row), " )\n";
                    throw $e;
                }
            }
        }

        $this->resetSequences();
    }

    /**
     * Reset DB sequences.
     */
    public function resetSequences()
    {
        switch ($this->db) {
            case 'pgsql':
                // Update PostgreSQL sequences
                $handler = $this->getDatabaseHandler();

                $queries = array_filter(preg_split('(;\\s*$)m',
                    file_get_contents(__DIR__ . '/_fixtures/setval.pgsql.sql')));
                foreach ($queries as $query) {
                    $handler->exec($query);
                }
        }
    }

    /**
     * Assert query result as correct.
     *
     * Builds text representations of the asserted and fetched query result,
     * based on a eZ\Publish\Core\Persistence\Database\SelectQuery object. Compares them using classic diff for
     * maximum readability of the differences between expectations and real
     * results.
     *
     * The expectation MUST be passed as a two dimensional array containing
     * rows of columns.
     *
     * @param array $expectation
     * @param \eZ\Publish\Core\Persistence\Database\SelectQuery $query
     * @param string $message
     */
    public static function assertQueryResult(array $expectation, SelectQuery $query, $message = '')
    {
        $statement = $query->prepare();
        $statement->execute();

        $result = [];
        while ($row = $statement->fetch(\PDO::FETCH_ASSOC)) {
            $result[] = $row;
        }

        return self::assertEquals(
            self::getResultTextRepresentation($expectation),
            self::getResultTextRepresentation($result),
            $message
        );
    }

    /**
     * Asserts correct property values on $object.
     *
     * Asserts that for all keys in $properties a corresponding property
     * exists in $object with the *same* value as in $properties.
     *
     * @param array $properties
     * @param object $object
     */
    protected function assertPropertiesCorrect(array $properties, $object)
    {
        if (!is_object($object)) {
            throw new InvalidArgumentException(
                'Received ' . gettype($object) . ' instead of object as second parameter'
            );
        }
        foreach ($properties as $propName => $propVal) {
            $this->assertSame(
                $propVal,
                $object->$propName,
                "Incorrect value for \${$propName}"
            );
        }
    }

    /**
     * Asserts $expStruct equals $actStruct in at least $propertyNames.
     *
     * Asserts that properties of $actStruct equal properties of $expStruct (not
     * vice versa!). If $propertyNames is null, all properties are checked.
     * Otherwise, $propertyNames provides a white list.
     *
     * @param object $expStruct
     * @param object $actStruct
     * @param array $propertyNames
     */
    protected function assertStructsEqual(
        $expStruct,
        $actStruct,
        array $propertyNames = null
    ) {
        if ($propertyNames === null) {
            $propertyNames = $this->getPublicPropertyNames($expStruct);
        }
        foreach ($propertyNames as $propName) {
            $this->assertEquals(
                $expStruct->$propName,
                $actStruct->$propName,
                "Properties \${$propName} not same"
            );
        }
    }

    /**
     * Returns public property names in $object.
     *
     * @param object $object
     *
     * @return array
     */
    protected function getPublicPropertyNames($object)
    {
        $refl = new ReflectionObject($object);

        return array_map(
            function ($prop) {
                return $prop->getName();
            },
            $refl->getProperties(ReflectionProperty::IS_PUBLIC)
        );
    }

    /**
     * @return string
     */
    protected static function getInstallationDir()
    {
        static $installDir = null;
        if ($installDir === null) {
            $config = require 'config.php';
            $installDir = $config['install_dir'];
        }

        return $installDir;
    }
}