Yiisoft\Db\Tests\Support\Mock

Complexity

Total Complexity

25

Size/Duplication

Total Lines	123
Duplicated Lines	0 %

Importance

Changes	5
Bugs	2	Features	0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	schemaCache()	0	7	2
A	getLogger()	0	3	1
A	__construct()	0	2	1
A	query()	0	3	1
A	connection()	0	9	2
A	schema()	0	3	1
A	prepareDatabase()	0	8	3
A	quoter()	0	3	1
A	cache()	0	7	2
A	queryCache()	0	7	2
A	getSchemaCache()	0	3	1
A	logger()	0	7	2
A	getDriverName()	0	3	1
A	getProfiler()	0	3	1
A	profiler()	0	7	2
A	queryBuilder()	0	3	1
A	getQueryCache()	0	3	1

<?php

declare(strict_types=1);

namespace Yiisoft\Db\Tests\Support;

use PHPUnit\Framework\TestCase;
use Psr\Log\LoggerInterface;
use Yiisoft\Cache\ArrayCache;
use Yiisoft\Cache\Cache;
use Yiisoft\Cache\CacheInterface;
use Yiisoft\Db\Cache\QueryCache;
use Yiisoft\Db\Cache\SchemaCache;
use Yiisoft\Db\Connection\ConnectionInterface;
use Yiisoft\Db\Driver\PDO\ConnectionPDOInterface;
use Yiisoft\Db\Query\Query;
use Yiisoft\Db\Query\QueryInterface;
use Yiisoft\Db\QueryBuilder\QueryBuilderInterface;
use Yiisoft\Db\Schema\QuoterInterface;
use Yiisoft\Db\Schema\SchemaInterface;
use Yiisoft\Db\Tests\Support\Stubs\Connection;
use Yiisoft\Log\Logger;
use Yiisoft\Profiler\Profiler;
use Yiisoft\Profiler\ProfilerInterface;

final class Mock extends TestCase
{
    private Cache|null $cache = null;
    private Logger|null $logger = null;
    private Profiler|null $profiler = null;
    private QueryCache|null $queryCache = null;
    private SchemaCache|null $schemaCache = null;

    public function __construct()
    {
    }

    public function connection(bool $prepareDatabase = false): ConnectionInterface
    {
        $db = new Connection();

        if ($prepareDatabase) {
            $this->prepareDatabase($db);
        }

        return $db;
    }

    public function getDriverName(): string
    {
        return $this->connection()->getDriver()->getDriverName();
    }

    public function getLogger(): Logger
    {
        return $this->logger();
    }

    public function getProfiler(): ProfilerInterface
    {
        return $this->profiler();
    }

    public function getQueryCache(): QueryCache
    {
        return $this->queryCache();
    }

    public function getSchemaCache(): SchemaCache
    {
        return $this->schemaCache();
    }

    public function query(): QueryInterface
    {
        return new Query($this->connection());
    }

    public function queryBuilder(): QueryBuilderInterface
    {
        return $this->connection()->getQueryBuilder();
    }

    public function quoter(): QuoterInterface
    {
        return $this->connection()->getQuoter();
    }

    public function schema(): SchemaInterface
    {
        return $this->connection()->getSchema();
    }

    private function cache(): CacheInterface
    {
        if ($this->cache === null) {
            $this->cache = new Cache(new ArrayCache());
        }

        return $this->cache;

The expression return $this->cache could return the type null which is incompatible with the type-hinted return Yiisoft\Cache\CacheInterface. Consider adding an additional type-check to rule them out.

    }

    private function logger(): LoggerInterface
    {
        if ($this->logger === null) {
            $this->logger = new Logger();
        }

        return $this->logger;

The expression return $this->logger could return the type null which is incompatible with the type-hinted return Psr\Log\LoggerInterface. Consider adding an additional type-check to rule them out.

    }

    private function prepareDatabase(ConnectionPDOInterface $db, string $fixture = __DIR__ . '/Fixture/sqlite.sql'): void
    {
        $db->open();
        $lines = explode(';', file_get_contents($fixture));

        foreach ($lines as $line) {
            if (trim($line) !== '') {
                $db->getPDO()?->exec($line);
            }
        }
    }

    private function profiler(): ProfilerInterface
    {
        if ($this->profiler === null) {
            $this->profiler = new Profiler($this->logger());
        }

        return $this->profiler;

The expression return $this->profiler could return the type null which is incompatible with the type-hinted return Yiisoft\Profiler\ProfilerInterface. Consider adding an additional type-check to rule them out.

    }

    private function queryCache(): QueryCache
    {
        if ($this->queryCache === null) {
            $this->queryCache = new QueryCache($this->cache());
        }

        return $this->queryCache;

The expression return $this->queryCache could return the type null which is incompatible with the type-hinted return Yiisoft\Db\Cache\QueryCache. Consider adding an additional type-check to rule them out.

    }

    private function schemaCache(): SchemaCache
    {
        if ($this->schemaCache === null) {
            $this->schemaCache = new SchemaCache($this->cache());
        }

        return $this->schemaCache;

The expression return $this->schemaCache could return the type null which is incompatible with the type-hinted return Yiisoft\Db\Cache\SchemaCache. Consider adding an additional type-check to rule them out.

    }
}