diff --git a/tests/Acceptance/Common/OrmTest.php b/tests/Acceptance/Common/OrmTest.php index 2b0f9a8..bde60a6 100644 --- a/tests/Acceptance/Common/OrmTest.php +++ b/tests/Acceptance/Common/OrmTest.php @@ -9,6 +9,8 @@ use Cycle\Testing\Tests\Fixtures\User; use Cycle\Testing\Tests\Fixtures\UserSchema; use Testo\Assert; +use Testo\Assert\State\Assertion\ComparisonFailure; +use Testo\Expect; use Testo\Lifecycle\BeforeTest; use Testo\Test; @@ -41,6 +43,33 @@ public function savesAndLoads(): void self::$previousOrm = $this->orm; } + public function savedEntityIsInSyncWithItsNode(): void + { + $user = new User(); + $user->email = 'b@example.com'; + $this->save($user); + + $extracted = $this->extractEntity($user); + $state = $this->orm->getHeap()->get($user)->getData(); + + Assert::same($extracted['email'], 'b@example.com'); + $this->assertEntitySynced('user', $extracted, $state); + } + + public function changedEntityIsOutOfSync(): never + { + $user = new User(); + $user->email = 'c@example.com'; + $this->save($user); + $state = $this->orm->getHeap()->get($user)->getData(); + # The plugin checks the heap after the test: keep the out-of-sync entity out of it. + $this->orm->getHeap()->clean(); + $user->email = 'changed@example.com'; + + Expect::exception(ComparisonFailure::class); + $this->assertEntitySynced('user', $this->extractEntity($user), $state); + } + public function freshOrmPerTest(): void { Assert::notSame($this->orm, self::$previousOrm); diff --git a/tests/Feature/Common/DatabaseContextTest.php b/tests/Feature/Common/DatabaseContextTest.php index 58a18f3..6409ada 100644 --- a/tests/Feature/Common/DatabaseContextTest.php +++ b/tests/Feature/Common/DatabaseContextTest.php @@ -74,6 +74,28 @@ public function tableBuilderMatchesDatabase(): void SchemaAssert::sameAsInDb($schema); } + public function compositeForeignKeySpansBothColumns(): void + { + $this->makeTable('pair', ['a' => 'integer', 'b' => 'integer'], pk: ['a', 'b']); + $this->makeTable('pair_ref', ['id' => 'primary', 'pa' => 'integer', 'pb' => 'integer']); + + $this->makeCompositeFK('pair_ref', ['pa', 'pb'], 'pair', ['a', 'b']); + + $schema = $this->schema('pair_ref'); + Assert::true($schema->hasForeignKey(['pa', 'pb'])); + Assert::same($schema->foreignKey(['pa', 'pb'])->getForeignKeys(), ['a', 'b']); + } + + public function fetchSchemaRereadsTheTable(): void + { + $this->makeTable('reread', ['id' => 'primary']); + $declared = $this->database->table('reread')->getSchema(); + $declared->string('added', 16)->nullable(true); + + Assert::true($declared->hasColumn('added')); + Assert::false($this->fetchSchema($declared)->hasColumn('added')); + } + public function dbVariantSharesServer(): void { $this->makeTable('shared', ['id' => 'primary']); diff --git a/tests/Feature/Common/WrapDriverTest.php b/tests/Feature/Common/WrapDriverTest.php index 740c741..51e64e6 100644 --- a/tests/Feature/Common/WrapDriverTest.php +++ b/tests/Feature/Common/WrapDriverTest.php @@ -4,6 +4,7 @@ namespace Cycle\Testing\Tests\Feature\Common; +use Cycle\Database\Exception\StatementException; use Cycle\Database\Exception\StatementException\ConnectionException; use Cycle\Testing\Database\Attribute\WrapDriver; use Cycle\Testing\Database\DatabaseTestCase; @@ -42,6 +43,47 @@ public function knobsAreResetBetweenTests(): void Assert::same($this->wrapDriver()->disconnectCalls, 0); } + public function queriesRunThroughTheWrappedPdo(): void + { + $this->makeTable('wrapped', ['id' => 'primary', 'name' => 'string(32)']); + $table = $this->database->table('wrapped'); + + $table->insertMultiple(['name'], [['a'], ['b']]); + + Assert::same($table->select('name')->orderBy('id')->fetchAll(), [['name' => 'a'], ['name' => 'b']]); + Assert::same($table->count(), 2); + } + + public function queryCallbackExecutesTheStatements(): void + { + $this->makeTable('called', ['id' => 'primary', 'name' => 'string(32)']); + $seen = []; + $this->wrapDriver()->setQueryCallback(static function (\PDOStatement $statement, ?array $params) use (&$seen): bool { + $seen[] = $statement->queryString; + return $statement->execute($params); + }); + + $this->database->table('called')->insertOne(['name' => 'a']); + $rows = $this->database->query('SELECT name FROM called WHERE name = ?', ['a'])->fetchAll(); + + Assert::count(\preg_grep('~^\s*INSERT INTO~i', $seen), 1); + Assert::string(\end($seen))->contains('WHERE name = ?'); + Assert::same($rows, [['name' => 'a']]); + } + + public function statementErrorsAreMappedByTheDriver(): void + { + try { + $this->database->query('SELECT * FROM no_such_table')->fetchAll(); + } catch (StatementException $e) { + Assert::false($e instanceof ConnectionException); + Assert::string($e->getQuery())->contains('no_such_table'); + return; + } + + Assert::fail('Querying a missing table did not fail.'); + } + public function failsTransactionBegin(): never { # The driver reconnects and retries once, so the first two begins must fail. diff --git a/tests/Unit/FakePDOTest.php b/tests/Unit/FakePDOTest.php new file mode 100644 index 0000000..e646bf9 --- /dev/null +++ b/tests/Unit/FakePDOTest.php @@ -0,0 +1,204 @@ +willReturn([['id' => 1], ['id' => 2]]); + + $statement = $pdo->query('SELECT id FROM t'); + + Assert::same($pdo->executed, [['sql' => 'SELECT id FROM t', 'params' => null]]); + Assert::same($statement->rowCount(), 2); + Assert::same(\iterator_to_array($statement), [['id' => 1], ['id' => 2]]); + } + + public function execRecordsAndCountsTheQueuedRows(): void + { + $pdo = (new FakePDO())->willReturn([['a' => 1], ['a' => 2], ['a' => 3]]); + + Assert::same($pdo->exec('DELETE FROM t'), 3); + Assert::same($pdo->exec('DELETE FROM t'), 0); + Assert::same($pdo->queries(), ['DELETE FROM t', 'DELETE FROM t']); + } + + public function execThrowsTheQueuedException(): never + { + $pdo = (new FakePDO())->willThrow(new \RuntimeException('gone')); + + Expect::exception(\RuntimeException::class)->withMessage('gone'); + $pdo->exec('DROP TABLE t'); + } + + public function tracksTheTransaction(): void + { + $pdo = new FakePDO(); + + Assert::false($pdo->inTransaction()); + Assert::true($pdo->beginTransaction()); + Assert::true($pdo->inTransaction()); + Assert::true($pdo->commit()); + Assert::false($pdo->inTransaction()); + + $pdo->beginTransaction(); + Assert::true($pdo->rollBack()); + Assert::false($pdo->inTransaction()); + } + + public function lastInsertIdIsScriptable(): void + { + $pdo = new FakePDO(); + Assert::same($pdo->lastInsertId(), '1'); + + $pdo->lastInsertId = '42'; + Assert::same($pdo->lastInsertId('seq'), '42'); + } + + public function keepsAttributes(): void + { + $pdo = new FakePDO(); + + Assert::null($pdo->getAttribute(\PDO::ATTR_CASE)); + Assert::true($pdo->setAttribute(\PDO::ATTR_CASE, \PDO::CASE_LOWER)); + Assert::same($pdo->getAttribute(\PDO::ATTR_CASE), \PDO::CASE_LOWER); + } + + public function reportsNoError(): void + { + $pdo = new FakePDO(); + + Assert::null($pdo->errorCode()); + Assert::same($pdo->errorInfo(), ['00000', null, null]); + } + + public function quotesByDoublingQuotes(): void + { + Assert::same((new FakePDO())->quote("it's"), "'it''s'"); + } + + public function boundValuesAreTheParamsWhenExecuteGetsNone(): void + { + $pdo = new FakePDO(); + $statement = $pdo->prepare('SELECT ? , ?'); + $byRef = 'b'; + + Assert::true($statement->bindValue(1, 'a')); + Assert::true($statement->bindParam(2, $byRef)); + $statement->execute(); + $statement->execute(['x']); + + Assert::same($pdo->executed[0]['params'], [1 => 'a', 2 => 'b']); + Assert::same($pdo->executed[1]['params'], ['x']); + } + + public function withoutBindingsExecutePassesNull(): void + { + $pdo = new FakePDO(); + + $pdo->prepare('SELECT 1')->execute(); + + Assert::null($pdo->executed[0]['params']); + } + + #[DataSet([\PDO::FETCH_ASSOC, ['id' => 1, 'name' => 'a']], 'assoc')] + #[DataSet([\PDO::FETCH_NUM, [1, 'a']], 'num')] + #[DataSet([\PDO::FETCH_COLUMN, 1], 'column')] + public function fetchShapesTheRow(int $mode, mixed $expected): void + { + $statement = self::executed([['id' => 1, 'name' => 'a']]); + + Assert::same($statement->fetch($mode), $expected); + Assert::false($statement->fetch($mode)); + } + + public function fetchObjModeGivesAnObject(): void + { + $row = self::executed([['id' => 1]])->fetch(\PDO::FETCH_OBJ); + + Assert::instanceOf($row, \stdClass::class); + Assert::same($row->id, 1); + } + + public function fetchColumnModeOfAnEmptyRowIsNull(): void + { + Assert::null(self::executed([[]])->fetch(\PDO::FETCH_COLUMN)); + } + + public function fetchAllShapesEveryRowAndDrains(): void + { + $statement = self::executed([['id' => 1, 'n' => 'a'], ['id' => 2, 'n' => 'b']]); + + Assert::same($statement->fetchAll(\PDO::FETCH_NUM), [[1, 'a'], [2, 'b']]); + Assert::same($statement->fetchAll(), []); + } + + public function fetchColumnTakesOneValuePerRow(): void + { + $statement = self::executed([['id' => 1, 'n' => 'a'], ['id' => 2]]); + + Assert::same($statement->fetchColumn(1), 'a'); + Assert::null($statement->fetchColumn(1)); + Assert::false($statement->fetchColumn()); + } + + public function fetchObjectGivesAStdClassThenFalse(): void + { + $statement = self::executed([['id' => 7]]); + + $row = $statement->fetchObject(); + + Assert::instanceOf($row, \stdClass::class); + Assert::same($row->id, 7); + Assert::false($statement->fetchObject()); + } + + public function columnCountComesFromTheFirstRow(): void + { + $statement = self::executed([['id' => 1, 'n' => 'a', 'x' => null]]); + + Assert::same($statement->columnCount(), 3); + Assert::true($statement->closeCursor()); + Assert::same($statement->columnCount(), 0); + Assert::same($statement->rowCount(), 0); + } + + public function statementStubsAnswerNeutrally(): void + { + $statement = self::executed([['id' => 1]]); + $column = null; + + Assert::true($statement->bindColumn(1, $column)); + Assert::true($statement->setAttribute(\PDO::ATTR_CURSOR_NAME, 'c')); + Assert::null($statement->getAttribute(\PDO::ATTR_CURSOR_NAME)); + Assert::true($statement->setFetchMode(\PDO::FETCH_NUM)); + Assert::false($statement->getColumnMeta(0)); + Assert::false($statement->nextRowset()); + Assert::null($statement->errorCode()); + Assert::same($statement->errorInfo(), ['00000', null, null]); + Assert::null($statement->debugDumpParams()); + Assert::same($statement->fetch(), ['id' => 1]); + } + + /** + * @param list> $rows + */ + private static function executed(array $rows): PDOStatementInterface + { + $statement = (new FakePDO())->willReturn($rows)->prepare('SELECT'); + $statement->execute(); + + return $statement; + } +} diff --git a/tests/Unit/PurgerTest.php b/tests/Unit/PurgerTest.php index 74a46dc..03a6f78 100644 --- a/tests/Unit/PurgerTest.php +++ b/tests/Unit/PurgerTest.php @@ -6,6 +6,7 @@ use Cycle\Database\Database; use Cycle\Testing\Database\Memory; +use Cycle\Testing\Database\Mock\StubDriver; use Cycle\Testing\Database\QueryLog; use Cycle\Testing\Database\Schema\Purger; use Cycle\Testing\Database\Schema\TableBuilder; @@ -51,6 +52,15 @@ public function dropTablesOnAnEmptyDatabaseOnlyLists(): void Assert::count($run['queries'], 1); } + public function dropTablesOfAnotherDriverFallsBackToDropAll(): void + { + $database = self::referencedRows(new Database('default', '', StubDriver::make())); + + Purger::dropTables($database->getDriver()); + + Assert::same($database->getTables(), []); + } + /** * `b_child` references `a_parent`, both have a row, and foreign keys are enforced. */ diff --git a/tests/Unit/SchemaSourceTest.php b/tests/Unit/SchemaSourceTest.php index 08cde77..3e7a0fe 100644 --- a/tests/Unit/SchemaSourceTest.php +++ b/tests/Unit/SchemaSourceTest.php @@ -11,6 +11,8 @@ use Cycle\Testing\ORM\Schema\SchemaCompiler; use Cycle\Testing\ORM\SchemaSource; use Cycle\Testing\Tests\Fixtures\Note; +use Cycle\Testing\Tests\Fixtures\User; +use Cycle\Testing\Tests\Fixtures\UserSchema; use Testo\Assert; use Testo\Test; @@ -59,6 +61,28 @@ public function ormRunsOnTheTwoDatabaseLayout(): void Assert::same($orm->getSource(Note::class)->getDatabase()->getName(), 'secondary'); } + public function emptyHasNoRoles(): void + { + Assert::same(SchemaSource::empty()->resolve()->getRoles(), []); + } + + public function fromFileReadsTheFileOnce(): void + { + $path = \tempnam(\sys_get_temp_dir(), 'cycle-testing-schema'); + \file_put_contents($path, 'resolve(); + } finally { + \unlink($path); + } + + Assert::same($schema->getRoles(), ['user']); + Assert::same($schema->define('user', SchemaInterface::ENTITY), User::class); + Assert::same($source->resolve(), $schema); + } + private static function notes(): SchemaSource { return SchemaSource::compiled( diff --git a/tests/Unit/StubDriverTest.php b/tests/Unit/StubDriverTest.php index e3ce1c1..2ec15a2 100644 --- a/tests/Unit/StubDriverTest.php +++ b/tests/Unit/StubDriverTest.php @@ -4,7 +4,10 @@ namespace Cycle\Testing\Tests\Unit; +use Cycle\Database\Config\DatabaseConfig; +use Cycle\Database\Config\SQLiteDriverConfig; use Cycle\Database\Database; +use Cycle\Database\DatabaseManager; use Cycle\Testing\Database\Mock\FakePDO; use Cycle\Testing\Database\Mock\StubDriver; use Testo\Assert; @@ -36,6 +39,19 @@ public function scriptedFailurePropagatesUnmapped(): never $db->select()->from('users')->fetchAll(); } + public function databaseManagerCreatesItFromItsConfig(): void + { + $dbal = new DatabaseManager(new DatabaseConfig([ + 'databases' => ['default' => ['connection' => 'stub']], + 'connections' => ['stub' => new SQLiteDriverConfig(driver: StubDriver::class)], + ])); + + $driver = $dbal->database()->getDriver(); + + Assert::instanceOf($driver, StubDriver::class); + Assert::same((int) $dbal->database()->query('SELECT 2 + 2')->fetchColumn(), 4); + } + public function withoutPdoUsesInMemorySqlite(): void { $db = new Database('default', '', StubDriver::make()); diff --git a/tests/Unit/TableRendererTest.php b/tests/Unit/TableRendererTest.php index 33aa06c..ee14f5c 100644 --- a/tests/Unit/TableRendererTest.php +++ b/tests/Unit/TableRendererTest.php @@ -4,10 +4,12 @@ namespace Cycle\Testing\Tests\Unit; +use Cycle\Database\Exception\SchemaException; use Cycle\Database\Schema\AbstractTable; use Cycle\Testing\Database\Memory; use Cycle\Testing\Database\Schema\TableRenderer; use Testo\Assert; +use Testo\Expect; use Testo\Test; #[Test] @@ -74,6 +76,12 @@ public function onlyWholeNumbersBecomeSizes(): void Assert::same($table->column('e')->getEnumValues(), ['1a', 'a1', '2']); } + public function definitionWithoutATypeIsRejected(): never + { + Expect::exception(SchemaException::class)->withMessage("Invalid column type definition in 't'.'n'"); + self::render(['n' => '(10)']); + } + /** * @param array $columns * @param array $defaults diff --git a/tests/Unit/TestPDOTest.php b/tests/Unit/TestPDOTest.php new file mode 100644 index 0000000..feeb101 --- /dev/null +++ b/tests/Unit/TestPDOTest.php @@ -0,0 +1,186 @@ +exec('CREATE TABLE t (id INTEGER PRIMARY KEY, name TEXT)'), 0); + Assert::same($pdo->exec("INSERT INTO t (name) VALUES ('a')"), 1); + Assert::same($pdo->lastInsertId(), '1'); + Assert::same($pdo->quote("it's"), "'it''s'"); + Assert::same($pdo->errorCode(), '00000'); + Assert::same($pdo->errorInfo()[0], '00000'); + Assert::true($pdo->setAttribute(\PDO::ATTR_DEFAULT_FETCH_MODE, \PDO::FETCH_ASSOC)); + Assert::same($pdo->getAttribute(\PDO::ATTR_DEFAULT_FETCH_MODE), \PDO::FETCH_ASSOC); + } + + public function unknownMethodsReachThePdo(): void + { + Assert::true(\in_array('sqlite', self::pdo()->getAvailableDrivers(), true)); + } + + public function runsTransactions(): void + { + $pdo = self::pdo(); + + Assert::true($pdo->beginTransaction()); + Assert::true($pdo->inTransaction()); + Assert::true($pdo->commit()); + $pdo->beginTransaction(); + Assert::true($pdo->rollBack()); + Assert::false($pdo->inTransaction()); + } + + public function failsTheGivenNumberOfBegins(): void + { + $failures = 1; + $pdo = new TestPDO(new \PDO('sqlite::memory:'), $failures, null); + + try { + $pdo->beginTransaction(); + Assert::fail('The first begin did not fail.'); + } catch (ConnectionException $e) { + Assert::same($e->getQuery(), 'Test exception'); + } + + Assert::same($failures, 0); + Assert::true($pdo->beginTransaction()); + } + + public function queryWrapsTheStatement(): void + { + $statement = self::pdo()->query('SELECT 1 AS one'); + + Assert::instanceOf($statement, TestPDOStatement::class); + Assert::same($statement->fetchColumn(), 1); + } + + public function failedQueryGivesFalse(): void + { + $pdo = self::pdo(); + $pdo->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_SILENT); + + Assert::false($pdo->query('SELECT * FROM missing')); + Assert::false($pdo->prepare('SELECT * FROM missing')); + } + + public function callbackReplacesExecute(): void + { + $seen = []; + $pdo = self::pdo(static function (\PDOStatement $statement, ?array $params) use (&$seen): bool { + $seen[] = [$statement->queryString, $params]; + return $statement->execute($params); + }); + + $statement = $pdo->prepare('SELECT ? AS v'); + + Assert::true($statement->execute(['x'])); + Assert::same($seen, [['SELECT ? AS v', ['x']]]); + Assert::same($statement->fetch(\PDO::FETCH_ASSOC), ['v' => 'x']); + } + + public function statementDelegatesFetching(): void + { + $pdo = self::pdo(); + $pdo->exec('CREATE TABLE t (id INTEGER PRIMARY KEY, name TEXT)'); + $pdo->exec("INSERT INTO t (name) VALUES ('a'), ('b'), ('c')"); + + $statement = $pdo->prepare('SELECT id, name FROM t WHERE id >= :min ORDER BY id'); + $min = 1; + Assert::true($statement->bindParam(':min', $min, \PDO::PARAM_INT)); + $statement->execute(); + + Assert::same($statement->columnCount(), 2); + Assert::same($statement->getColumnMeta(1)['name'], 'name'); + Assert::same($statement->fetch(\PDO::FETCH_NUM), [1, 'a']); + Assert::same($statement->fetchObject()->name, 'b'); + Assert::same($statement->fetchAll(\PDO::FETCH_COLUMN, 1), ['c']); + Assert::true($statement->closeCursor()); + } + + public function statementAsksThePdoStatementForTheNextRowset(): never + { + $statement = self::pdo()->query('SELECT 1'); + + # SQLite has no multiple rowsets: the PDO statement refuses. + Expect::exception(\PDOException::class); + $statement->nextRowset(); + } + + public function statementBindsValuesAndColumns(): void + { + $statement = self::pdo()->prepare('SELECT :v AS v'); + Assert::true($statement->bindValue(':v', 'x')); + $statement->execute(); + + $v = null; + Assert::true($statement->bindColumn('v', $v)); + Assert::true($statement->setFetchMode(\PDO::FETCH_ASSOC)); + Assert::same($statement->fetch(), ['v' => 'x']); + Assert::same($statement->rowCount(), 0); + Assert::same($statement->errorCode(), '00000'); + Assert::same($statement->errorInfo()[0], '00000'); + } + + public function statementIsIterable(): void + { + $statement = self::pdo()->query('SELECT 1 AS a UNION ALL SELECT 2'); + $statement->setFetchMode(\PDO::FETCH_NUM); + + Assert::same(\iterator_to_array($statement->getIterator(), false), [[1], [2]]); + } + + public function statementAttributesReachThePdoStatement(): never + { + $statement = self::pdo()->prepare('SELECT 1'); + + Expect::exception(\PDOException::class); + $statement->getAttribute(\PDO::ATTR_CURSOR_NAME); + } + + public function statementAttributeWritesReachThePdoStatement(): void + { + $pdo = new \PDO('sqlite::memory:', options: [\PDO::ATTR_ERRMODE => \PDO::ERRMODE_SILENT]); + $failures = 0; + $statement = (new TestPDO($pdo, $failures, null))->prepare('SELECT 1'); + + # Whether SQLite accepts the attribute depends on the PHP version: the wrapper answers as PDO does. + Assert::same( + $statement->setAttribute(\PDO::ATTR_CURSOR_NAME, 'c'), + $pdo->prepare('SELECT 1')->setAttribute(\PDO::ATTR_CURSOR_NAME, 'c'), + ); + } + + public function statementDumpsItsParams(): void + { + $statement = self::pdo()->prepare('SELECT :v'); + + \ob_start(); + $result = $statement->debugDumpParams(); + $dump = (string) \ob_get_clean(); + + Assert::null($result); + Assert::string($dump)->contains('SELECT :v'); + } + + private static function pdo(?\Closure $queryCallback = null): TestPDO + { + $failures = 0; + + return new TestPDO(new \PDO('sqlite::memory:'), $failures, $queryCallback); + } +}