From 6a3bcc5011719d7a88f2adbad264458e418d8957 Mon Sep 17 00:00:00 2001 From: roxblnfk Date: Fri, 20 Nov 2026 20:44:49 +0400 Subject: [PATCH 1/9] test(orm): cover every branch of the heap integrity check Assisted-By: Claude Opus 5.5 --- tests/Fixtures/FailingMapper.php | 15 ++ tests/Fixtures/RenamingMapper.php | 18 ++ tests/Fixtures/ShadowedParent.php | 10 + tests/Fixtures/ShadowingEntity.php | 32 +++ tests/Unit/HeapIntegrityTest.php | 315 ++++++++++++++++++++++++++++- 5 files changed, 387 insertions(+), 3 deletions(-) create mode 100644 tests/Fixtures/FailingMapper.php create mode 100644 tests/Fixtures/RenamingMapper.php create mode 100644 tests/Fixtures/ShadowedParent.php create mode 100644 tests/Fixtures/ShadowingEntity.php diff --git a/tests/Fixtures/FailingMapper.php b/tests/Fixtures/FailingMapper.php new file mode 100644 index 0000000..8e46df0 --- /dev/null +++ b/tests/Fixtures/FailingMapper.php @@ -0,0 +1,15 @@ + 'renamed'] + parent::extract($entity); + } +} diff --git a/tests/Fixtures/ShadowedParent.php b/tests/Fixtures/ShadowedParent.php new file mode 100644 index 0000000..0adf2d5 --- /dev/null +++ b/tests/Fixtures/ShadowedParent.php @@ -0,0 +1,10 @@ + [ + S::ENTITY => self::class, + S::MAPPER => StrictMapper::class, + S::DATABASE => 'default', + S::TABLE => 'shadowing', + S::PRIMARY_KEY => 'id', + S::COLUMNS => ['id', 'name'], + S::SCHEMA => [], + S::RELATIONS => [], + ], + ]; + } +} diff --git a/tests/Unit/HeapIntegrityTest.php b/tests/Unit/HeapIntegrityTest.php index b2c2ff4..771d8af 100644 --- a/tests/Unit/HeapIntegrityTest.php +++ b/tests/Unit/HeapIntegrityTest.php @@ -5,13 +5,24 @@ namespace Cycle\Testing\Tests\Unit; use Cycle\ORM\EntityManager; +use Cycle\ORM\Mapper\Mapper; +use Cycle\ORM\ORMInterface; +use Cycle\ORM\Reference\Reference; +use Cycle\ORM\Relation; +use Cycle\ORM\SchemaInterface as S; use Cycle\Testing\Database\Schema\TableBuilder; use Cycle\Testing\ORM\HeapIntegrity; use Cycle\Testing\ORM\Memory; +use Cycle\Testing\Tests\Fixtures\FailingMapper; +use Cycle\Testing\Tests\Fixtures\RenamingMapper; +use Cycle\Testing\Tests\Fixtures\ShadowingEntity; use Cycle\Testing\Tests\Fixtures\TypedEntity; use Cycle\Testing\Tests\Fixtures\User; use Cycle\Testing\Tests\Fixtures\UserSchema; +use Doctrine\Common\Collections\ArrayCollection; use Testo\Assert; +use Testo\Core\Exception\SkipTest; +use Testo\Expect; use Testo\Test; #[Test] @@ -33,6 +44,38 @@ public function unsavedChangeIsReported(): void Assert::same(HeapIntegrity::violations($orm), ['Entity and State are not in sync `user`.`email`']); } + public function everyUnsavedChangeIsReported(): void + { + [$orm, $user] = self::savedUser(); + $user->email = 'changed@example.com'; + $user->balance = 10.0; + + Assert::same(HeapIntegrity::violations($orm), [ + 'Entity and State are not in sync `user`.`email`', + 'Entity and State are not in sync `user`.`balance`', + ]); + } + + public function entityIsReadThroughItsMapper(): void + { + $schema = UserSchema::schema(); + $schema['user'][S::MAPPER] = RenamingMapper::class; + [$orm] = self::savedUser($schema); + + Assert::same(HeapIntegrity::violations($orm), ['Entity and State are not in sync `user`.`email`']); + } + + public function mapperErrorsOtherThanUninitializedPropertiesPropagate(): never + { + $schema = UserSchema::schema(); + $schema['user'][S::MAPPER] = FailingMapper::class; + [$orm] = self::savedUser($schema); + + Expect::exception(\Error::class)->withMessage('mapper failed'); + + HeapIntegrity::violations($orm); + } + public function uninitializedTypedPropertiesAreSkipped(): void { $orm = Memory::orm(TypedEntity::schema()); @@ -42,12 +85,227 @@ public function uninitializedTypedPropertiesAreSkipped(): void Assert::same(HeapIntegrity::violations($orm), []); } + public function initializedPropertiesOfPartlyInitializedEntityAreCompared(): void + { + $orm = Memory::orm(TypedEntity::schema()); + $entity = $orm->make('typed', ['name' => 'a', 'note' => 'n']); + $entity->name = 'b'; + $entity->note = 'm'; + + Assert::same(HeapIntegrity::violations($orm), [ + 'Entity and State are not in sync `typed`.`name`', + 'Entity and State are not in sync `typed`.`note`', + ]); + } + + public function propertyShadowingAParentPrivateOneIsReadFromTheEntityClass(): void + { + $orm = Memory::orm(ShadowingEntity::schema()); + $entity = $orm->make('shadowing', ['name' => 'a']); + $entity->name = 'b'; + + Assert::same(HeapIntegrity::violations($orm), ['Entity and State are not in sync `shadowing`.`name`']); + } + + public function fieldsAreComparedLoosely(): void + { + $orm = self::relationOrm(); + + Assert::same(HeapIntegrity::entityViolations($orm, 'post', ['a' => '1', 'b' => [1, '2']], ['a' => 1, 'b' => ['1', 2]], []), []); + } + + public function arraysDifferInLengthKeysOrValues(): void + { + $orm = self::relationOrm(); + + $violations = HeapIntegrity::entityViolations( + $orm, + 'post', + ['a' => [1], 'b' => ['x' => 1], 'c' => [1, 2], 'd' => [1], 'e' => 'x'], + ['a' => [1, 2], 'b' => ['y' => 1], 'c' => [1, 3], 'd' => 'x', 'e' => [1]], + [], + ); + + Assert::same($violations, [ + 'Entity and State are not in sync `post`.`a`', + 'Entity and State are not in sync `post`.`b`', + 'Entity and State are not in sync `post`.`c`', + 'Entity and State are not in sync `post`.`d`', + 'Entity and State are not in sync `post`.`e`', + ]); + } + + public function objectsAreEqualOnlyWhenOfOneClassAndEqualState(): void + { + $orm = self::relationOrm(); + $user = self::user('a'); + + $violations = HeapIntegrity::entityViolations( + $orm, + 'post', + ['same' => $user, 'equal' => self::user('a'), 'differ' => self::user('a'), 'class' => new \ArrayObject(), 'scalar' => $user], + ['same' => $user, 'equal' => self::user('a'), 'differ' => self::user('b'), 'class' => new \ArrayIterator(), 'scalar' => 1], + [], + ); + + Assert::same($violations, [ + 'Entity and State are not in sync `post`.`differ`', + 'Entity and State are not in sync `post`.`class`', + 'Entity and State are not in sync `post`.`scalar`', + ]); + } + + public function recursiveGraphsAreNotEqual(): void + { + if (\PHP_VERSION_ID < 80400) { + # Before PHP 8.4 `==` on a recursive graph is a fatal error, which equals() cannot catch. + throw new SkipTest('Comparing recursive graphs is fatal before PHP 8.4.'); + } + + $orm = self::relationOrm(); + [$a, $b] = [new \stdClass(), new \stdClass()]; + $a->self = $a; + $b->self = $b; + + Assert::same(HeapIntegrity::entityViolations($orm, 'post', ['a' => $a], ['a' => $b], []), [ + 'Entity and State are not in sync `post`.`a`', + ]); + } + + public function fieldsOutsideStateAndRelationsAreSkipped(): void + { + $orm = self::relationOrm(); + + $violations = HeapIntegrity::entityViolations($orm, 'post', ['extra' => 1, 'title' => 'a'], ['title' => 'b'], []); + + Assert::same($violations, ['Entity and State are not in sync `post`.`title`']); + } + + public function relationMissingFromSchemaIsReported(): void + { + $orm = self::relationOrm(); + + $violations = HeapIntegrity::entityViolations($orm, 'bare', ['tags' => [], 'title' => 'a'], ['title' => 'b'], ['tags' => []]); + + Assert::same($violations, [ + 'Relation `tags` is not found among the roles of `bare` and its parents.', + 'Entity and State are not in sync `bare`.`title`', + ]); + } + + public function relationsAreFoundOnParentRoles(): void + { + $orm = self::relationOrm(); + + $violations = HeapIntegrity::entityViolations($orm, 'child', ['author' => self::user('a')], [], ['author' => self::user('b')]); + + Assert::same($violations, ['Entity and State are not in sync `child`.`author`']); + } + + public function embeddedRelationsAreSkipped(): void + { + $orm = self::relationOrm(); + + $violations = HeapIntegrity::entityViolations( + $orm, + 'post', + ['address' => self::user('a'), 'author' => self::user('a')], + [], + ['address' => self::user('b'), 'author' => self::user('b')], + ); + + Assert::same($violations, ['Entity and State are not in sync `post`.`author`']); + } + + public function identicalRelationValueEndsTheEntityCheck(): void + { + $orm = self::relationOrm(); + $user = self::user('a'); + + $violations = HeapIntegrity::entityViolations( + $orm, + 'post', + ['title' => 'a', 'body' => 'a', 'author' => $user, 'subtitle' => 'a'], + ['title' => 'b', 'body' => 'b', 'subtitle' => 'b'], + ['author' => $user], + ); + + Assert::same($violations, [ + 'Entity and State are not in sync `post`.`title`', + 'Entity and State are not in sync `post`.`body`', + ]); + } + + public function loadedReferencesAreComparedByValue(): void + { + $orm = self::relationOrm(); + $user = self::user('a'); + + $violations = HeapIntegrity::entityViolations( + $orm, + 'post', + ['author' => self::reference('user', ['id' => 1], $user), 'tags' => [self::user('a')]], + [], + ['author' => self::reference('user', ['id' => 2], self::user('a')), 'tags' => self::reference('user', [], [self::user('b')])], + ); + + Assert::same($violations, ['Entity and State are not in sync `post`.`tags`']); + } + + public function unloadedReferencesAreComparedByScopeAndRole(): void + { + $orm = self::relationOrm(); + + $violations = HeapIntegrity::entityViolations( + $orm, + 'post', + ['author' => new Reference('user', ['id' => 1]), 'tags' => new Reference('user', ['id' => 1]), 'other' => new Reference('user', ['id' => '1'])], + [], + ['author' => new Reference('user', ['id' => 2]), 'tags' => new Reference('tag', ['id' => 1]), 'other' => new Reference('user', ['id' => 1])], + ); + + Assert::same($violations, [ + 'Entity and State are not in sync `post`.`author` (Reference scope)', + 'Entity and State are not in sync `post`.`tags` (Reference role)', + ]); + } + + public function referenceAgainstEntityIsAMismatch(): void + { + $orm = self::relationOrm(); + + $violations = HeapIntegrity::entityViolations( + $orm, + 'post', + ['author' => self::user('a')], + [], + ['author' => new Reference('user', ['id' => 1])], + ); + + Assert::same($violations, ['Entity and State are not in sync `post`.`author`']); + } + + public function collectionsAreComparedAsLists(): void + { + $orm = self::relationOrm(); + + $violations = HeapIntegrity::entityViolations( + $orm, + 'post', + ['tags' => [self::user('a')], 'other' => new \ArrayIterator([]), 'items' => new \ArrayIterator([self::user('a')]), 'author' => new \ArrayIterator(['k' => self::user('a')])], + [], + ['tags' => new ArrayCollection(['k' => self::user('a')]), 'other' => null, 'items' => [self::user('a')], 'author' => [self::user('a')]], + ); + + Assert::same($violations, ['Entity and State are not in sync `post`.`author`']); + } + /** - * @return array{\Cycle\ORM\ORMInterface, User} + * @return array{ORMInterface, User} */ - private static function savedUser(): array + private static function savedUser(?array $schema = null): array { - $orm = Memory::orm(UserSchema::schema()); + $orm = Memory::orm($schema ?? UserSchema::schema()); $database = $orm->getFactory()->database('default'); \assert($database instanceof \Cycle\Database\Database); (new TableBuilder($database))->makeTable('user', UserSchema::COLUMNS); @@ -58,4 +316,55 @@ private static function savedUser(): array return [$orm, $user]; } + + /** + * An ORM whose schema is only read, never queried: `post` has a belongs-to, a has-many and an embedded + * relation, `child` inherits them, `bare` defines no relations at all. + */ + private static function relationOrm(): ORMInterface + { + $relation = static fn(int $type, string $target): array => [ + Relation::TYPE => $type, + Relation::TARGET => $target, + Relation::LOAD => Relation::LOAD_PROMISE, + Relation::SCHEMA => [], + ]; + $role = static fn(string $role): array => [ + S::ENTITY => $role, + S::MAPPER => Mapper::class, + S::DATABASE => 'default', + S::TABLE => $role, + S::PRIMARY_KEY => 'id', + S::COLUMNS => ['id'], + ]; + + return Memory::orm([ + 'user' => $role('user') + [S::RELATIONS => []], + 'post' => $role('post') + [S::RELATIONS => [ + 'author' => $relation(Relation::BELONGS_TO, 'user'), + 'tags' => $relation(Relation::HAS_MANY, 'user'), + 'other' => $relation(Relation::HAS_MANY, 'user'), + 'items' => $relation(Relation::HAS_MANY, 'user'), + 'address' => $relation(Relation::EMBEDDED, 'user'), + ]], + 'child' => $role('child') + [S::PARENT => 'post', S::RELATIONS => []], + 'bare' => $role('bare'), + ]); + } + + private static function user(string $email): User + { + $user = new User(); + $user->email = $email; + + return $user; + } + + private static function reference(string $role, array $scope, mixed $value): Reference + { + $reference = new Reference($role, $scope); + $reference->setValue($value); + + return $reference; + } } From bc0fd695984f95dfb165687b0f520133483dd965 Mon Sep 17 00:00:00 2001 From: roxblnfk Date: Fri, 20 Nov 2026 20:44:50 +0400 Subject: [PATCH 2/9] test(regression): cover the new-case command, namespace lookup and template sets Assisted-By: Claude Opus 5.5 --- tests/Unit/CaseGeneratorTest.php | 78 +++++++++++++++++ tests/Unit/CommandTest.php | 143 +++++++++++++++++++++++++++++++ tests/Unit/TemplateSetTest.php | 102 ++++++++++++++++++++++ 3 files changed, 323 insertions(+) create mode 100644 tests/Unit/CommandTest.php create mode 100644 tests/Unit/TemplateSetTest.php diff --git a/tests/Unit/CaseGeneratorTest.php b/tests/Unit/CaseGeneratorTest.php index 5c967f1..ff15b28 100644 --- a/tests/Unit/CaseGeneratorTest.php +++ b/tests/Unit/CaseGeneratorTest.php @@ -8,6 +8,8 @@ use Cycle\Testing\Regression\Command; use Cycle\Testing\Regression\TemplateSet; use Testo\Assert; +use Testo\Data\DataSet; +use Testo\Expect; use Testo\Lifecycle\AfterTest; use Testo\Test; @@ -53,6 +55,82 @@ public function namespaceFromTheLongestPsr4Root(): void ); } + #[DataSet(['12a'], 'digits then letters')] + #[DataSet(['a-b'], 'a dash after a valid start')] + #[DataSet(['-b'], 'a dash before a valid end')] + public function caseNameMustBeANamespaceSegment(string $issue): never + { + Expect::exception(\InvalidArgumentException::class) + ->withMessage("`{$issue}` is neither an issue number nor a valid namespace segment."); + + CaseGenerator::caseName($issue); + } + + public function namespaceNeedsComposerJson(): never + { + $root = $this->project([]); + \unlink("{$root}/composer.json"); + + Expect::exception(\RuntimeException::class)->withMessage("No composer.json in `{$root}`."); + + CaseGenerator::namespaceOf($root, 'tests/Regression'); + } + + public function namespaceOutsideEveryRootFails(): never + { + $root = $this->project(['autoload' => ['psr-4' => ['App\\' => 'src/']]]); + + Expect::exception(\RuntimeException::class)->withMessageContaining('`tests/Regression` is under no PSR-4 root'); + + CaseGenerator::namespaceOf($root, 'tests/Regression'); + } + + /** + * @param array> $dev + * @param array> $prod + */ + #[DataSet([[], ['App\\Tests\\' => 'tests/']], 'from autoload when autoload-dev has no match')] + #[DataSet([['App\\' => ''], [], 'App\tests\Regression\Issue1'], 'from the root mapping')] + #[DataSet([['App\\Tests\\' => 'tests/', 'Long\\' => 'tests-longer-folder/']], 'ignoring a longer root it is not under')] + #[DataSet([['Other\\' => 'lib/', 'App\\Tests\\' => 'tests/']], 'after a root it is not under')] + #[DataSet([['App\\Tests\\' => ['lib/', 'tests/']]], 'from the second path of a root')] + #[DataSet([['App\\Tests\\' => 'tests/', 'Other\\Tests\\' => 'tests/']], 'from the first of equal roots')] + #[DataSet([['App\\Tests\\' => './tests']], 'from a dot-relative root')] + #[DataSet([['App\\Tests\\' => 'tests\\']], 'from a root with backslashes')] + #[DataSet([['App\\Tests\\' => 'tests/'], ['Prod\\' => 'tests/Regression/']], 'from autoload-dev before autoload')] + public function namespaceOfIssueFolder(array $dev, array $prod = [], string $expected = 'App\Tests\Regression\Issue1'): void + { + $root = $this->project(['autoload-dev' => ['psr-4' => $dev], 'autoload' => ['psr-4' => $prod]]); + + Assert::same(CaseGenerator::namespaceOf($root, 'tests/Regression/Issue1'), $expected); + } + + public function namespaceOfTheRootFolderItself(): void + { + $root = $this->project(['autoload-dev' => ['psr-4' => ['App\\Tests\\' => 'tests/Regression']]]); + + Assert::same(CaseGenerator::namespaceOf($root, 'tests\\Regression'), 'App\Tests'); + } + + public function namespaceFromTheLongerRootEvenWithAShortPrefix(): void + { + $root = $this->project(['autoload-dev' => ['psr-4' => ['Very\\Long\\Prefix\\' => 'tests/', 'Short\\' => 'tests/Regression/']]]); + + Assert::same(CaseGenerator::namespaceOf($root, 'tests/Regression/Issue1'), 'Short\Issue1'); + } + + public function generateFillsAnEmptyExistingFolder(): void + { + $root = $this->project([]); + \mkdir("{$root}/case"); + $set = TemplateSet::load('orm'); + + $written = (new CaseGenerator())->generate($set, "{$root}/case", 'Acme\Case1'); + + Assert::same($written, \array_map(static fn(string $file): string => "{$root}/case/{$file}", \array_keys($set->files))); + Assert::same(\fileperms("{$root}/case/Entity") & 07777, 0777 & ~\umask()); + } + public function overlayReplacesOnlyItsFiles(): void { $set = TemplateSet::load('orm-behaviors'); diff --git a/tests/Unit/CommandTest.php b/tests/Unit/CommandTest.php new file mode 100644 index 0000000..43dfd3e --- /dev/null +++ b/tests/Unit/CommandTest.php @@ -0,0 +1,143 @@ +root = \str_replace('\\', '/', \sys_get_temp_dir()) . '/cycle-testing-command-' . \bin2hex(\random_bytes(4)); + \mkdir($this->root); + \file_put_contents("{$this->root}/composer.json", '{"autoload-dev": {"psr-4": {"Acme\\\\Tests\\\\": "tests/"}}}'); + $this->out = \fopen('php://memory', 'w+'); + $this->err = \fopen('php://memory', 'w+'); + } + + #[AfterTest] + public function removeProject(): void + { + $files = new \RecursiveIteratorIterator( + new \RecursiveDirectoryIterator($this->root, \FilesystemIterator::SKIP_DOTS), + \RecursiveIteratorIterator::CHILD_FIRST, + ); + foreach ($files as $file) { + \assert($file instanceof \SplFileInfo); + $file->isDir() ? \rmdir($file->getPathname()) : \unlink($file->getPathname()); + } + \rmdir($this->root); + } + + #[DataSet([[]], 'no arguments')] + #[DataSet([['--help']], 'help')] + #[DataSet([['unknown', '--help']], 'help with an unknown command')] + #[DataSet([['--dir=a' . "\n" . 'b']], 'option value spanning lines')] + public function usageOnRequestGoesToOutput(array $argv): void + { + $code = $this->run($argv); + + Assert::same($code, 0); + Assert::string($this->output())->startsWith('Usage:'); + Assert::same($this->errors(), ''); + } + + #[DataSet([['unknown']], 'unknown command')] + #[DataSet([['unknown--help']], 'option marker inside an argument')] + #[DataSet([['--help!']], 'option name with a trailing symbol')] + public function usageOnAnUnknownCommandGoesToErrors(array $argv): void + { + $code = $this->run($argv); + + Assert::same($code, 1); + Assert::string($this->errors())->startsWith('Usage:'); + Assert::same($this->output(), ''); + } + + public function templatesListsEverySetWithItsDescription(): void + { + $expected = ''; + foreach (TemplateSet::all() as $set) { + Assert::notSame($set->description, ''); + $expected .= \sprintf("%-16s %s\n", $set->name, $set->description); + } + + $code = $this->run(['templates']); + + Assert::same($code, 0); + Assert::same($this->output(), $expected); + } + + public function newCaseWithoutIssueFailsWithUsage(): void + { + $code = $this->run(['new-case']); + + Assert::same($code, 1); + Assert::string($this->errors()) + ->startsWith("new-case needs an issue number or a case name.\n\nUsage:") + ->endsWith("List the built-in templates.\n\n"); + } + + public function optionWithoutRequiredValueFails(): void + { + $code = $this->run(['new-case', '1', '--template']); + + Assert::same($code, 1); + Assert::same($this->errors(), "--template needs a value: --template=.\n"); + } + + public function newCaseReportsTheWrittenFiles(): void + { + $code = $this->run(['new-case', 'Case1', '--template=database', '--dir=tests\\Cases/', '--namespace=\\Acme\\Cases\\']); + + Assert::same($code, 0); + $expected = "Created tests/Cases/Case1 (Acme\\Cases\\Case1, template database):\n"; + foreach (\array_keys(TemplateSet::load('database')->files) as $file) { + $expected .= " tests/Cases/Case1/{$file}\n"; + } + Assert::same($this->output(), $expected); + Assert::string((string) \file_get_contents("{$this->root}/tests/Cases/Case1/CaseTest.php")) + ->contains("namespace Acme\\Cases\\Case1;\n"); + } + + public function newCaseTakesTheNamespaceFromComposer(): void + { + $code = $this->run(['new-case', '5', '--template=database']); + + Assert::same($code, 0); + Assert::string($this->output())->startsWith("Created tests/Regression/Issue5 (Acme\\Tests\\Regression\\Issue5, template database):\n"); + } + + private function run(array $argv): int + { + return (new Command($this->root, $this->out, $this->err))->run($argv); + } + + private function output(): string + { + return (string) \stream_get_contents($this->out, offset: 0); + } + + private function errors(): string + { + return (string) \stream_get_contents($this->err, offset: 0); + } +} diff --git a/tests/Unit/TemplateSetTest.php b/tests/Unit/TemplateSetTest.php new file mode 100644 index 0000000..6f109da --- /dev/null +++ b/tests/Unit/TemplateSetTest.php @@ -0,0 +1,102 @@ +root = \str_replace('\\', '/', \sys_get_temp_dir()) . '/cycle-testing-templates-' . \bin2hex(\random_bytes(4)); + \mkdir($this->root); + } + + #[AfterTest] + public function removeRoot(): void + { + $files = new \RecursiveIteratorIterator( + new \RecursiveDirectoryIterator($this->root, \FilesystemIterator::SKIP_DOTS), + \RecursiveIteratorIterator::CHILD_FIRST, + ); + foreach ($files as $file) { + \assert($file instanceof \SplFileInfo); + $file->isDir() ? \rmdir($file->getPathname()) : \unlink($file->getPathname()); + } + \rmdir($this->root); + } + + public function loadsFromTheGivenRoot(): void + { + $this->set('base', ['description' => 'Base set'], ['A.php', 'Sub/B.php']); + $this->set('child', ['extends' => 'base'], ['Sub/B.php', 'C.php']); + + $base = TemplateSet::load('base', $this->root); + $child = TemplateSet::load('child', $this->root); + + Assert::same($base->description, 'Base set'); + Assert::same($child->description, ''); + Assert::same(\array_map(static fn(string $p): string => \str_replace('\\', '/', $p), $child->files), [ + 'A.php' => "{$this->root}/base/A.php", + 'C.php' => "{$this->root}/child/C.php", + 'Sub/B.php' => "{$this->root}/child/Sub/B.php", + ]); + } + + public function allLoadsEveryFolderOfTheRoot(): void + { + $this->set('one', ['description' => 'First'], ['A.php']); + $this->set('two', ['description' => 'Second'], ['B.php']); + \file_put_contents("{$this->root}/README.md", ''); + + $sets = TemplateSet::all($this->root); + + Assert::same(\array_map(static fn(TemplateSet $set): string => $set->name, $sets), ['one', 'two']); + Assert::same($sets[1]->description, 'Second'); + } + + public function circularExtendsFails(): never + { + $this->set('a', ['extends' => 'b'], []); + $this->set('b', ['extends' => 'a'], []); + + Expect::exception(\RuntimeException::class)->withMessage('Template `a` extends itself through `a` → `b`.'); + + TemplateSet::load('a', $this->root); + } + + public function unknownTemplateNamesTheAvailableOnes(): never + { + $this->set('one', [], []); + $this->set('two', [], []); + + Expect::exception(\InvalidArgumentException::class)->withMessage('Unknown template `three`; available: one, two.'); + + TemplateSet::load('three', $this->root); + } + + /** + * @param array{extends?: string, description?: string} $manifest + * @param list $files + */ + private function set(string $name, array $manifest, array $files): void + { + \mkdir("{$this->root}/{$name}"); + $manifest === [] or \file_put_contents("{$this->root}/{$name}/template.json", \json_encode($manifest)); + foreach ($files as $file) { + \is_dir(\dirname("{$this->root}/{$name}/{$file}")) or \mkdir(\dirname("{$this->root}/{$name}/{$file}"), recursive: true); + \file_put_contents("{$this->root}/{$name}/{$file}", ' Date: Fri, 20 Nov 2026 21:01:24 +0400 Subject: [PATCH 3/9] test(database): cover the schema, SQL and query assertions, failures included Assisted-By: Claude Opus 5.5 --- tests/Feature/Common/QueryCountersTest.php | 14 ++ tests/Unit/QueryAssertTest.php | 75 +++++++ tests/Unit/SchemaAssertTest.php | 218 +++++++++++++++++++++ tests/Unit/SqlAssertTest.php | 56 ++++++ 4 files changed, 363 insertions(+) create mode 100644 tests/Unit/QueryAssertTest.php create mode 100644 tests/Unit/SchemaAssertTest.php diff --git a/tests/Feature/Common/QueryCountersTest.php b/tests/Feature/Common/QueryCountersTest.php index 40b3649..18d1bb6 100644 --- a/tests/Feature/Common/QueryCountersTest.php +++ b/tests/Feature/Common/QueryCountersTest.php @@ -4,7 +4,9 @@ namespace Cycle\Testing\Tests\Feature\Common; +use Cycle\Testing\Database\Assert\QueryAssert; use Cycle\Testing\Database\DatabaseTestCase; +use Cycle\Testing\Database\QueryLog; use Testo\Lifecycle\BeforeTest; use Testo\Test; @@ -42,4 +44,16 @@ public function withoutCaptureCountsFromTheTestStart(): void $this->assertNumWrites(1); } + + public function queryAssertCountsOnTheSuiteLog(): void + { + QueryAssert::writes(1, fn() => $this->database->table('counted')->insertOne(['name' => 'e'])); + } + + public function queryAssertPrefersTheGivenLog(): void + { + $log = new QueryLog(); + + QueryAssert::count(0, 1, fn() => $log->info('DELETE FROM t', ['elapsed' => 0.1]), $log); + } } diff --git a/tests/Unit/QueryAssertTest.php b/tests/Unit/QueryAssertTest.php new file mode 100644 index 0000000..9cd0c8e --- /dev/null +++ b/tests/Unit/QueryAssertTest.php @@ -0,0 +1,75 @@ +info('SELECT 1', ['elapsed' => 0.1]); + $log->info('DELETE FROM t', ['elapsed' => 0.1]); + + return 'done'; + }, $log); + + Assert::same($result, 'done'); + Assert::same(QueryAssert::none(static fn(): int => 5, $log), 5); + } + + public function unexpectedReadsFailWithTheExecutedQueries(): never + { + $log = new QueryLog(); + + Expect::exception(AssertionException::class)->withMessageContaining("Expected 0 read queries. Executed:\nSELECT 1\nSELECT 2"); + + QueryAssert::reads(0, static function () use ($log): void { + $log->info('SELECT 1', ['elapsed' => 0.1]); + $log->info('SELECT 2', ['elapsed' => 0.1]); + }, $log); + } + + public function missingWritesFailWithNoneExecuted(): never + { + Expect::exception(AssertionException::class)->withMessageContaining("Expected 1 write queries. Executed:\n(none)"); + + QueryAssert::writes(1, static fn() => null, new QueryLog()); + } + + public function countChecksTheReads(): never + { + $log = new QueryLog(); + + Expect::exception(AssertionException::class)->withMessageContaining('Expected 0 read queries.'); + + QueryAssert::count(0, 0, static fn() => $log->info('SELECT 1', ['elapsed' => 0.1]), $log); + } + + public function countChecksTheWrites(): never + { + $log = new QueryLog(); + + Expect::exception(AssertionException::class)->withMessageContaining('Expected 0 write queries.'); + + QueryAssert::count(0, 0, static fn() => $log->info('DELETE FROM t', ['elapsed' => 0.1]), $log); + } + + public function outsideADatabaseSuiteTheLogIsRequired(): never + { + Expect::exception(\LogicException::class)->withMessage('No query log: run inside a database suite or pass one.'); + + QueryAssert::none(static fn() => null); + } +} diff --git a/tests/Unit/SchemaAssertTest.php b/tests/Unit/SchemaAssertTest.php new file mode 100644 index 0000000..5a2596c --- /dev/null +++ b/tests/Unit/SchemaAssertTest.php @@ -0,0 +1,218 @@ + 'primary', 'parent_id' => 'integer', 'amount' => 'decimal(10, 2)', 'status' => 'enum(a, b)']; + + public static function declaredChanges(): iterable + { + yield 'primary key' => [static function (AbstractTable $t): void { + $t->setPrimaryKeys(['id', 'parent_id']); + }, 'Primary keys changed']; + yield 'column added' => [static function (AbstractTable $t): void { + $t->string('extra'); + }, 'Column number has changed']; + yield 'index added' => [static function (AbstractTable $t): void { + $t->index(['status']); + }, 'Index number has changed']; + yield 'column renamed' => [static function (AbstractTable $t): void { + $t->renameColumn('status', 'state'); + }, 'Column t.state has been removed']; + yield 'index replaced' => [static function (AbstractTable $t): void { + $t->dropIndex(['amount']); + $t->index(['status'])->unique(); + }, 'has been removed']; + yield 'FK replaced' => [static function (AbstractTable $t): void { + $t->dropForeignKey(['parent_id']); + $t->foreignKey(['status'])->references('parent', ['id']); + $t->dropIndex(['status']); + }, 'FK t_status_fk has been removed']; + yield 'column type' => [static function (AbstractTable $t): void { + $t->string('status'); + }, 'Column t.status type has been changed']; + yield 'column scale' => [static function (AbstractTable $t): void { + $t->decimal('amount', 10, 3); + }, 'Column t.amount scale has been changed']; + yield 'column precision' => [static function (AbstractTable $t): void { + $t->decimal('amount', 9, 2); + }, 'Column t.amount precision has been changed']; + yield 'enum values' => [static function (AbstractTable $t): void { + $t->enum('status', ['a', 'c']); + }, 'Column t.status enum values have been changed']; + yield 'nullability' => [static function (AbstractTable $t): void { + $t->column('parent_id')->nullable(true); + }, 'Column t.parent_id has been changed']; + yield 'index uniqueness' => [static function (AbstractTable $t): void { + $t->index(['amount'])->unique(false); + }, 'uniqueness has been changed']; + yield 'FK delete rule' => [static function (AbstractTable $t): void { + $t->foreignKey(['parent_id'])->onDelete(ForeignKeyInterface::NO_ACTION); + }, 'delete rule has been changed']; + yield 'FK update rule' => [static function (AbstractTable $t): void { + $t->foreignKey(['parent_id'])->onUpdate(ForeignKeyInterface::NO_ACTION); + }, 'update rule has been changed']; + } + + public static function foreignKeyChanges(): iterable + { + yield 'columns' => [static function (AbstractTable $t): mixed { + return $t->foreignKey(['status'])->references('parent', ['id']); + }, 'columns have been changed']; + yield 'foreign table' => [static function (AbstractTable $t): mixed { + return $t->foreignKey(['parent_id'])->references('t', ['id']); + }, 'table has been changed']; + yield 'foreign keys' => [static function (AbstractTable $t): mixed { + return $t->foreignKey(['parent_id'])->references('parent', ['code']); + }, 'keys have been changed']; + } + + public function savedTableMatchesTheDatabase(): void + { + $table = self::saved()->table('t')->getSchema(); + + SchemaAssert::sameAsInDb($table); + } + + public function comparesWithTheGivenTarget(): never + { + $database = self::saved(); + (new TableBuilder($database))->makeTable('other', self::COLUMNS, fk: ['parent_id' => ['table' => 'parent', 'column' => 'id']]); + + Expect::exception(AssertionException::class)->withMessageContaining('Table name changed'); + + SchemaAssert::sameAsInDb($database->table('t')->getSchema(), $database->table('other')->getSchema()); + } + + public function foreignKeyMissingFromTheTargetFails(): never + { + $target = Memory::database(); + $builder = new TableBuilder($target); + $builder->makeTable('parent', ['id' => 'primary', 'code' => 'integer']); + $builder->makeTable('t', self::COLUMNS); + $builder->makeIndex('t', ['parent_id']); + $builder->makeIndex('t', ['amount'], unique: true); + + Expect::exception(AssertionException::class)->withMessageContaining('FK number has changed'); + + SchemaAssert::sameAsInDb(self::saved()->table('t')->getSchema(), $target->table('t')->getSchema()); + } + + /** + * @param \Closure(AbstractTable): void $change + */ + #[DataProvider('declaredChanges')] + public function declaredChangeIsReported(\Closure $change, string $message): never + { + $table = self::saved()->table('t')->getSchema(); + $change($table); + + Expect::exception(AssertionException::class)->withMessageContaining($message); + + SchemaAssert::sameAsInDb($table); + } + + public function missingColumnFails(): never + { + $column = self::saved()->table('t')->getSchema()->column('amount'); + + Expect::exception(AssertionException::class)->withMessageContaining('Column t.amount is missing'); + + SchemaAssert::sameColumn($column, null); + } + + public function missingIndexFails(): never + { + $index = self::saved()->table('t')->getSchema()->index(['amount']); + + Expect::exception(AssertionException::class)->withMessageContaining("Index {$index->getName()} is missing"); + + SchemaAssert::sameIndex($index, null); + } + + public function indexOnOtherColumnsFails(): never + { + $table = self::saved()->table('t')->getSchema(); + + Expect::exception(AssertionException::class)->withMessageContaining('columns have been changed'); + + SchemaAssert::sameIndex($table->index(['amount']), $table->index(['status'])); + } + + public function indexUnderAnotherNameFails(): never + { + $table = self::saved()->table('t')->getSchema(); + $renamed = clone $table->index(['amount']); + $renamed->setName('renamed'); + + Expect::exception(AssertionException::class)->withMessageContaining('has been changed'); + + SchemaAssert::sameIndex($table->index(['amount']), $renamed); + } + + public function missingForeignKeyFails(): never + { + $key = self::saved()->table('t')->getSchema()->foreignKey(['parent_id']); + + Expect::exception(AssertionException::class)->withMessageContaining("FK {$key->getName()} is missing"); + + SchemaAssert::sameForeignKey($key, null); + } + + /** + * @param \Closure(AbstractTable): mixed $declare + */ + #[DataProvider('foreignKeyChanges')] + public function foreignKeyChangeIsReported(\Closure $declare, string $message): never + { + $table = self::saved()->table('t')->getSchema(); + $saved = clone $table->foreignKey(['parent_id']); + $declared = $declare($table); + + Expect::exception(AssertionException::class)->withMessageContaining($message); + + SchemaAssert::sameForeignKey($saved, $declared); + } + + public function foreignKeyUnderAnotherNameFails(): never + { + # Unlike SQLite's, a Postgres key compares its name too. + $key = (new PostgresForeignKey('t', '', 'fk_t_parent'))->columns(['parent_id'])->references('parent', ['id']); + $renamed = clone $key; + $renamed->setName('renamed'); + + Expect::exception(AssertionException::class)->withMessageContaining("FK {$key->getName()} has been changed"); + + SchemaAssert::sameForeignKey($key, $renamed); + } + + /** + * A database with `parent` and `t`: a unique index on `t.amount` and a cascading FK `t.parent_id`. + */ + private static function saved(): Database + { + $database = Memory::database(); + $builder = new TableBuilder($database); + $builder->makeTable('parent', ['id' => 'primary', 'code' => 'integer']); + $builder->makeTable('t', self::COLUMNS, fk: ['parent_id' => ['table' => 'parent', 'column' => 'id']]); + $builder->makeIndex('t', ['amount'], unique: true); + + return $database; + } +} diff --git a/tests/Unit/SqlAssertTest.php b/tests/Unit/SqlAssertTest.php index 430b39c..84ba3be 100644 --- a/tests/Unit/SqlAssertTest.php +++ b/tests/Unit/SqlAssertTest.php @@ -4,10 +4,13 @@ namespace Cycle\Testing\Tests\Unit; +use Cycle\Database\Injection\Fragment; use Cycle\Testing\Database\Assert\SqlAssert; use Cycle\Testing\Database\Driver; use Cycle\Testing\Database\Memory; use Testo\Assert; +use Testo\Assert\State\Assertion\AssertionException; +use Testo\Expect; use Testo\Test; #[Test] @@ -37,6 +40,59 @@ public function mismatchFails(): void Assert::fail('No failure for different SQL.'); } + public function fragmentIsComparedAsSql(): void + { + SqlAssert::same(new Fragment('SELECT "a"'), 'SELECT {a}', Driver::SQLite); + } + + public function withoutDriverOtherSqlFails(): never + { + Expect::exception(AssertionException::class)->withMessageContaining('SELECTa'); + + SqlAssert::same('SELECT a', 'SELECT b'); + } + + public function givenDriverDecidesTheQuotes(): never + { + Expect::exception(AssertionException::class)->withMessageContaining('SELECT`a`'); + + SqlAssert::same('SELECT "a"', 'SELECT {a}', Driver::MySQL); + } + + public function givenConnectionDecidesTheQuotes(): never + { + Expect::exception(AssertionException::class)->withMessageContaining('SELECT`a`'); + + SqlAssert::same('SELECT `a`', 'SELECT {a}', Memory::database()->getDriver()); + } + + public function otherParametersFail(): never + { + $query = Memory::database()->select('id')->from('users')->where('id', 7); + + Expect::exception(AssertionException::class); + + SqlAssert::sameParameters($query, [8]); + } + + public function sqlWithParametersChecksTheSql(): never + { + $query = Memory::database()->select('id')->from('users')->where('id', 7); + + Expect::exception(AssertionException::class)->withMessageContaining('name'); + + SqlAssert::sameWithParameters($query, 'SELECT {name} FROM {users} WHERE {id} = ?', [7], Driver::SQLite); + } + + public function sqlWithParametersChecksTheParameters(): never + { + $query = Memory::database()->select('id')->from('users')->where('id', 7); + + Expect::exception(AssertionException::class); + + SqlAssert::sameWithParameters($query, 'SELECT {id} FROM {users} WHERE {id} = ?', [8], Driver::SQLite); + } + public function queryAndParameters(): void { $query = Memory::database()->select('id')->from('users')->where('id', 7); From ff33d973c5c899bbab6fe5fa06a19792f58fd5cc Mon Sep 17 00:00:00 2001 From: roxblnfk Date: Fri, 20 Nov 2026 21:01:25 +0400 Subject: [PATCH 4/9] test(database): run the driver suites in a nested application to check the interceptors The interceptors work around each test, outside its coverage window, so the feature tests that check isolation never counted for them. Assisted-By: Claude Opus 5.5 --- .../HarnessSuite/Functions/functions.php | 17 ++ .../Isolation/AttachCountingCase.php | 32 +++ .../HarnessSuite/Isolation/DropTablesCase.php | 29 +++ .../Isolation/NoIsolationCase.php | 33 +++ .../HarnessSuite/Isolation/PlainCase.php | 20 ++ .../HarnessSuite/Memory/ReconnectCase.php | 38 +++ .../HarnessSuite/Orm/SkippedHeapCheckCase.php | 32 +++ .../HarnessSuite/Orm/UnsyncedHeapCase.php | 30 +++ .../HarnessSuite/Prepared/PreparedCase.php | 32 +++ tests/Unit/HarnessTest.php | 245 ++++++++++++++++++ 10 files changed, 508 insertions(+) create mode 100644 tests/Fixtures/HarnessSuite/Functions/functions.php create mode 100644 tests/Fixtures/HarnessSuite/Isolation/AttachCountingCase.php create mode 100644 tests/Fixtures/HarnessSuite/Isolation/DropTablesCase.php create mode 100644 tests/Fixtures/HarnessSuite/Isolation/NoIsolationCase.php create mode 100644 tests/Fixtures/HarnessSuite/Isolation/PlainCase.php create mode 100644 tests/Fixtures/HarnessSuite/Memory/ReconnectCase.php create mode 100644 tests/Fixtures/HarnessSuite/Orm/SkippedHeapCheckCase.php create mode 100644 tests/Fixtures/HarnessSuite/Orm/UnsyncedHeapCase.php create mode 100644 tests/Fixtures/HarnessSuite/Prepared/PreparedCase.php create mode 100644 tests/Unit/HarnessTest.php diff --git a/tests/Fixtures/HarnessSuite/Functions/functions.php b/tests/Fixtures/HarnessSuite/Functions/functions.php new file mode 100644 index 0000000..7d30540 --- /dev/null +++ b/tests/Fixtures/HarnessSuite/Functions/functions.php @@ -0,0 +1,17 @@ +attached; + } + + #[Test] + public function first(): void + { + Assert::same($this->attached, 1); + } + + #[Test] + public function second(): void + { + Assert::same($this->attached, 1); + } +} diff --git a/tests/Fixtures/HarnessSuite/Isolation/DropTablesCase.php b/tests/Fixtures/HarnessSuite/Isolation/DropTablesCase.php new file mode 100644 index 0000000..4660df2 --- /dev/null +++ b/tests/Fixtures/HarnessSuite/Isolation/DropTablesCase.php @@ -0,0 +1,29 @@ +makeTable('left_behind', ['id' => 'primary']); + $this->database->begin(); + + Assert::true($this->database->hasTable('left_behind')); + } + + public function startsWithoutThem(): void + { + Assert::false($this->database->hasTable('left_behind')); + } +} diff --git a/tests/Fixtures/HarnessSuite/Isolation/NoIsolationCase.php b/tests/Fixtures/HarnessSuite/Isolation/NoIsolationCase.php new file mode 100644 index 0000000..0a8a93a --- /dev/null +++ b/tests/Fixtures/HarnessSuite/Isolation/NoIsolationCase.php @@ -0,0 +1,33 @@ +makeTable('kept', ['id' => 'primary']); + $this->database->begin(); + + Assert::same($this->database->getDriver()->getTransactionLevel(), 1); + } + + public function startsOutsideATransactionWithTheTableKept(): void + { + Assert::same($this->database->getDriver()->getTransactionLevel(), 0); + Assert::true($this->database->hasTable('kept')); + } +} diff --git a/tests/Fixtures/HarnessSuite/Isolation/PlainCase.php b/tests/Fixtures/HarnessSuite/Isolation/PlainCase.php new file mode 100644 index 0000000..fd7ab3d --- /dev/null +++ b/tests/Fixtures/HarnessSuite/Isolation/PlainCase.php @@ -0,0 +1,20 @@ +database->execute('CREATE TEMP TABLE temp_left_behind (id INTEGER)'); + + Assert::same(self::temporaryTables($this->database), ['temp_left_behind']); + } + + public function startsWithoutIt(): void + { + Assert::same(self::temporaryTables($this->database), []); + } + + /** + * @return list + */ + private static function temporaryTables(Database $database): array + { + return \array_column($database->query('SELECT name FROM sqlite_temp_master')->fetchAll(), 'name'); + } +} diff --git a/tests/Fixtures/HarnessSuite/Orm/SkippedHeapCheckCase.php b/tests/Fixtures/HarnessSuite/Orm/SkippedHeapCheckCase.php new file mode 100644 index 0000000..47da7da --- /dev/null +++ b/tests/Fixtures/HarnessSuite/Orm/SkippedHeapCheckCase.php @@ -0,0 +1,32 @@ +makeTable('user', UserSchema::COLUMNS); + $this->withSchema(UserSchema::schema()); + $user = new User(); + $this->save($user); + + $user->email = 'changed@example.com'; + + Assert::notNull($user->id); + } +} diff --git a/tests/Fixtures/HarnessSuite/Orm/UnsyncedHeapCase.php b/tests/Fixtures/HarnessSuite/Orm/UnsyncedHeapCase.php new file mode 100644 index 0000000..161e6c9 --- /dev/null +++ b/tests/Fixtures/HarnessSuite/Orm/UnsyncedHeapCase.php @@ -0,0 +1,30 @@ +makeTable('user', UserSchema::COLUMNS); + $this->withSchema(UserSchema::schema()); + $user = new User(); + $this->save($user); + + $user->email = 'changed@example.com'; + + Assert::notNull($user->id); + } +} diff --git a/tests/Fixtures/HarnessSuite/Prepared/PreparedCase.php b/tests/Fixtures/HarnessSuite/Prepared/PreparedCase.php new file mode 100644 index 0000000..ddf2707 --- /dev/null +++ b/tests/Fixtures/HarnessSuite/Prepared/PreparedCase.php @@ -0,0 +1,32 @@ +database->getDriver()->connect(); + } + + public function seesThePreparedRowsOnly(): void + { + Assert::same($this->database->table('prepared')->count(), 1); + Assert::false($this->database->hasTable('leftover')); + } +} diff --git a/tests/Unit/HarnessTest.php b/tests/Unit/HarnessTest.php new file mode 100644 index 0000000..a90006a --- /dev/null +++ b/tests/Unit/HarnessTest.php @@ -0,0 +1,245 @@ +file === null or @\unlink($this->file); + $this->file = null; + } + + public function featureSuitePassesOnSqlite(): void + { + $results = self::run(['Feature/Common', 'Feature/SQLite'], [new DatabasePlugin(Driver::SQLite)]); + + self::assertAllPassed($results); + } + + public function acceptanceSuitePassesOnSqlite(): void + { + $results = self::run(['Acceptance/Common'], [new DatabasePlugin(Driver::SQLite), new OrmPlugin()]); + + self::assertAllPassed($results); + } + + public function isolationHoldsOnAnInMemoryDatabase(): void + { + $results = self::run( + ['Fixtures/HarnessSuite/Isolation', 'Fixtures/HarnessSuite/Memory', 'Fixtures/HarnessSuite/Functions'], + [new DatabasePlugin(Driver::SQLite)], + ); + + self::assertAllPassed($results); + Assert::count($results, 10); + } + + public function isolationHoldsOnADatabaseFile(): void + { + $env = Env::load()->with(['DB_SQLITE_FILE' => $this->file()]); + + $results = self::run(['Fixtures/HarnessSuite/Isolation'], [new DatabasePlugin(Driver::SQLite, env: $env)]); + + self::assertAllPassed($results); + } + + public function queriesGoToTheQuerySqlChannel(): void + { + $results = self::run(['Fixtures/HarnessSuite/Memory'], [new DatabasePlugin(Driver::SQLite)]); + + $messages = \array_map( + static fn(Message $message): string => $message->content, + $results['ReconnectCase::leavesATemporaryTable']->messages->channel('query.sql'), + ); + Assert::string(\implode('', $messages))->contains('CREATE TEMP TABLE temp_left_behind'); + } + + public function suiteStartsFromPreparedTablesOnly(): void + { + $file = $this->file(); + $leftover = SQLiteDriver::create(new SQLiteDriverConfig(connection: new FileConnectionConfig($file))); + $leftover->execute('CREATE TABLE leftover (id INTEGER)'); + $leftover->disconnect(); + $pool = null; + $prepare = static function (DatabaseContext $context) use (&$pool): void { + $pool = $context->pool; + $context->database()->execute('CREATE TABLE prepared (id INTEGER)'); + $context->database()->execute('INSERT INTO prepared VALUES (1)'); + }; + + $results = self::run(['Fixtures/HarnessSuite/Prepared'], [new DatabasePlugin( + Driver::SQLite, + Isolation::Transaction, + prepare: $prepare, + env: Env::load()->with(['DB_SQLITE_FILE' => $file]), + )]); + + self::assertAllPassed($results); + Assert::instanceOf($pool, ConnectionPool::class); + foreach ($pool->drivers() as $driver) { + Assert::false($driver->isConnected()); + } + } + + public function failingPrepareSkipsTheSuite(): void + { + $prepare = static function (): void { + throw new \RuntimeException('no seed'); + }; + + $results = self::run(['Fixtures/HarnessSuite/Prepared'], [new DatabasePlugin(Driver::SQLite, prepare: $prepare, env: self::optional())]); + + $result = $results['PreparedCase::seesThePreparedRowsOnly']; + Assert::same($result->status, Status::Skipped); + Assert::same($result->failure?->getMessage(), 'Preparing the SQLite database failed: no seed'); + } + + public function unreachableDatabaseSkipsTheSuite(): void + { + $results = self::run(['Fixtures/HarnessSuite/Prepared'], [new DatabasePlugin(Driver::SQLite, env: self::unreachable())]); + + $result = $results['PreparedCase::seesThePreparedRowsOnly']; + Assert::same($result->status, Status::Skipped); + Assert::instanceOf($result->failure, SkipTest::class); + Assert::string((string) $result->failure?->getMessage())->startsWith('SQLite at sqlite:')->contains(' is unreachable: '); + } + + public function unreachableRequiredDatabaseFailsTheSuite(): void + { + $env = self::unreachable()->with(['DB_REQUIRED' => '1']); + + $results = self::run(['Fixtures/HarnessSuite/Prepared'], [new DatabasePlugin(Driver::SQLite, env: $env)]); + + $result = $results['PreparedCase::seesThePreparedRowsOnly']; + Assert::same($result->status, Status::Failed); + Assert::instanceOf($result->failure, \RuntimeException::class); + Assert::false($result->failure instanceof SkipTest); + Assert::string((string) $result->failure?->getMessage())->contains(' is unreachable: '); + } + + public function heapCheckFailsAnUnsyncedTest(): void + { + $results = self::run(['Fixtures/HarnessSuite/Orm', 'Fixtures/HarnessSuite/Functions'], [new DatabasePlugin(Driver::SQLite), new OrmPlugin()]); + + Assert::same($results['UnsyncedHeapCase::changesASavedEntity']->status, Status::Failed); + Assert::same($results['SkippedHeapCheckCase::changesASavedEntity']->status, Status::Passed); + Assert::same($results['functions::runsWithoutACaseClass']->status, Status::Passed); + } + + public function heapCheckCanBeTurnedOff(): void + { + $unbound = 0; + $bind = static function () use (&$unbound): \Closure { + return static function () use (&$unbound): void { + ++$unbound; + }; + }; + + $results = self::run( + ['Fixtures/HarnessSuite/Orm', 'Fixtures/HarnessSuite/Functions'], + [new DatabasePlugin(Driver::SQLite), new OrmPlugin(heapCheck: false, bind: $bind)], + ); + + self::assertAllPassed($results); + Assert::same($unbound, \count($results)); + } + + /** + * @param array $results + */ + private static function assertAllPassed(array $results): void + { + Assert::notBlank($results); + $failed = \array_filter($results, static fn(TestResult $r): bool => $r->status !== Status::Passed); + Assert::same(\array_map(static fn(TestResult $r): string => (string) $r->failure?->getMessage(), $failed), []); + } + + /** + * An SQLite file in a folder that does not exist. + */ + private static function unreachable(): Env + { + return self::optional()->with(['DB_SQLITE_FILE' => \sys_get_temp_dir() . '/cycle-testing-missing-' . \bin2hex(\random_bytes(4)) . '/db.sqlite']); + } + + /** + * CI exports `DB_REQUIRED=1`, which would turn the skips under test into failures. + */ + private static function optional(): Env + { + return Env::load()->with(['DB_REQUIRED' => '0']); + } + + /** + * @param list $folders Under `tests/`. + * @param list $plugins + * @return array `Case::test` (short class name) => result. + */ + private static function run(array $folders, array $plugins): array + { + $root = \dirname(__DIR__); + $result = Application::createFromConfig(new ApplicationConfig(suites: [new SuiteConfig( + name: 'Nested', + location: new FinderConfig(\array_map(static fn(string $f): string => "{$root}/{$f}", $folders)), + plugins: $plugins, + )]))->run(); + + $results = []; + foreach ($result as $suite) { + foreach ($suite as $case) { + foreach ($case as $test) { + \assert($test instanceof TestResult); + $class = $test->info->caseInfo->definition->reflection?->getShortName() ?? 'functions'; + $results["{$class}::{$test->info->name}"] = $test; + } + } + } + + return $results; + } + + /** + * @return non-empty-string A fresh SQLite file path, removed after the test. + */ + private function file(): string + { + return $this->file = \sys_get_temp_dir() . '/cycle-testing-harness-' . \bin2hex(\random_bytes(4)) . '.sqlite'; + } +} From 9d105fdb98635d201e6d6a7fe9b83f10a6b6f3ac Mon Sep 17 00:00:00 2001 From: roxblnfk Date: Fri, 20 Nov 2026 21:12:05 +0400 Subject: [PATCH 5/9] test(config): cover suite assembly, the env file parser and driver selection Assisted-By: Claude Opus 5.5 --- tests/Unit/ConfigTest.php | 111 ++++++++++++++++++++++++++++++++++++++ tests/Unit/EnvTest.php | 98 +++++++++++++++++++++++++++++++-- 2 files changed, 204 insertions(+), 5 deletions(-) diff --git a/tests/Unit/ConfigTest.php b/tests/Unit/ConfigTest.php index dd2b3be..e10ee5a 100644 --- a/tests/Unit/ConfigTest.php +++ b/tests/Unit/ConfigTest.php @@ -7,10 +7,13 @@ use Cycle\Testing\Config; use Cycle\Testing\Database\DatabasePlugin; use Cycle\Testing\Database\Driver; +use Cycle\Testing\Database\Env; use Cycle\Testing\Database\Isolation; +use Cycle\Testing\ORM\OrmPlugin; use Testo\Application\Config\SuiteConfig; use Testo\Assert; use Testo\Bridge\Mockery\MockeryPlugin; +use Testo\Codecov\CodecovPlugin; use Testo\Lifecycle\AfterTest; use Testo\Test; @@ -106,6 +109,114 @@ public function repoWithoutTestFoldersBuildsAnEmptySuite(): void Assert::same($config->src->includes, []); } + public function unitSuiteGetsMockeryAndTheGivenPlugins(): void + { + $plugin = new OrmPlugin(); + $plugins = (static function () use ($plugin): \Generator { + yield 'orm' => $plugin; + })(); + + $config = Config::forPackage('cycle/testing', root: \dirname(__DIR__, 2)) + ->unit('tests/Unit', plugins: $plugins) + ->unit('tests/Unit', plugins: ['orm' => $plugin], name: 'Again') + ->build(); + + foreach ($config->suites as $suite) { + Assert::array([...$suite->plugins])->isList()->hasCount(2); + Assert::instanceOf([...$suite->plugins][0], MockeryPlugin::class); + Assert::same([...$suite->plugins][1], $plugin); + } + } + + public function driverSuitesGetTheGivenPluginsAfterTheDatabase(): void + { + [$first, $second] = [new OrmPlugin(), new OrmPlugin()]; + + $config = Config::forPackage('cycle/testing', root: \dirname(__DIR__, 2)) + ->feature('tests/Feature/', drivers: [Driver::SQLite], plugins: [$first, $second]) + ->build(); + + $plugins = [...$config->suites[0]->plugins]; + Assert::count($plugins, 4); + Assert::instanceOf($plugins[1], DatabasePlugin::class); + Assert::same([$plugins[2], $plugins[3]], [$first, $second]); + } + + public function rootAndPathsMayEndWithASlash(): void + { + $root = $this->tempTree(['tests/Feature/Common']); + + $config = Config::forPackage('cycle/smoke', root: "{$root}/") + ->feature('tests/Feature/', drivers: [Driver::SQLite]) + ->build(); + + Assert::same(self::paths($config->suites[0]->location->includes), ["{$root}/tests/Feature/Common"]); + } + + public function driverFoldersCanBeRenamed(): void + { + $root = $this->tempTree(['tests/Feature/Common', 'tests/Feature/MySql8', 'tests/Feature/MySQL']); + + $config = Config::forPackage('cycle/smoke', root: $root) + ->feature('tests/Feature', drivers: [Driver::MySQL], folders: ['mysql' => 'MySql8']) + ->build(); + + Assert::same(self::paths($config->suites[0]->location->includes), ["{$root}/tests/Feature/Common", "{$root}/tests/Feature/MySql8"]); + } + + public function wholePathSuiteExcludesEveryOtherDriverAndTheGivenPaths(): void + { + $root = $this->tempTree(['tests/Regression/Fixtures', 'tests/Regression/MySQL', 'tests/Regression/Postgres', 'tests/Regression/SQLite']); + + $config = Config::forPackage('cycle/orm', root: $root) + ->regression('tests/Regression', drivers: [Driver::SQLite], exclude: ['tests/Regression/Fixtures']) + ->build(); + + Assert::same(self::paths($config->suites[0]->location->excludes), [ + "{$root}/tests/Regression/Fixtures", + "{$root}/tests/Regression/MySQL", + "{$root}/tests/Regression/Postgres", + ]); + } + + public function driversComeFromTheGivenEnv(): void + { + $saved = \getenv('DB_DRIVERS'); + \putenv('DB_DRIVERS'); + + try { + $config = Config::forPackage('cycle/testing', root: \dirname(__DIR__, 2), env: new Env(['DB_DRIVERS' => 'postgres'])) + ->feature('tests/Feature') + ->build(); + } finally { + $saved === false or \putenv("DB_DRIVERS={$saved}"); + } + + Assert::same(self::names($config->suites), ['Feature/Postgres']); + } + + public function addingASuiteLeavesTheOriginalConfigAlone(): void + { + $base = Config::forPackage('cycle/testing', root: \dirname(__DIR__, 2)); + + $base->unit('tests/Unit'); + $base->plugins(new OrmPlugin()); + + Assert::same(self::names($base->build()->suites), ['Unit']); + Assert::count([...$base->build()->plugins], 1); + } + + public function buildCollectsCoverageOnlyOnRequest(): void + { + $plugin = new OrmPlugin(); + + $plugins = [...Config::forPackage('cycle/testing', root: \dirname(__DIR__, 2))->plugins($plugin)->build()->plugins]; + + Assert::count($plugins, 2); + Assert::instanceOf($plugins[0], CodecovPlugin::class); + Assert::same($plugins[1], $plugin); + } + /** * @param list $suites * @return list diff --git a/tests/Unit/EnvTest.php b/tests/Unit/EnvTest.php index 84d46a4..5655b62 100644 --- a/tests/Unit/EnvTest.php +++ b/tests/Unit/EnvTest.php @@ -9,16 +9,32 @@ use Testo\Assert; use Testo\Expect; use Testo\Lifecycle\AfterTest; +use Testo\Lifecycle\BeforeTest; use Testo\Test; #[Test] final class EnvTest { - #[AfterTest] + private const VARIABLES = ['DB_DRIVERS', 'DB', 'CYCLE_TESTING_PROBE']; + + /** @var array The variables as the run started with them, e.g. `DB_DRIVERS` in CI. */ + private array $saved = []; + + #[BeforeTest] public function clearEnvironment(): void { - \putenv('DB_DRIVERS'); - \putenv('CYCLE_TESTING_PROBE'); + foreach (self::VARIABLES as $name) { + $this->saved[$name] = \getenv($name); + \putenv($name); + } + } + + #[AfterTest] + public function restoreEnvironment(): void + { + foreach ($this->saved as $name => $value) { + \putenv($value === false ? $name : "{$name}={$value}"); + } } public function shippedDefaultsCoverEveryDriver(): void @@ -36,13 +52,85 @@ public function shippedDefaultsCoverEveryDriver(): void public function parsesCommentsAndQuotes(): void { $file = \tempnam(\sys_get_temp_dir(), 'env'); - \file_put_contents($file, "# comment\n\nA=1\nB = \"two words\"\nC='x=y'\n"); + \file_put_contents($file, "# comment\n\nA=1\nB = \"two words\"\nC='x=y'\n # D=1\n#E=1\nF=\"\"\nG=xax\nH=\"mixed'\nI=x\n"); $env = Env::fromFile($file); \unlink($file); Assert::same($env->get('A'), '1'); Assert::same($env->get('B'), 'two words'); Assert::same($env->get('C'), 'x=y'); + Assert::same($env->get('# D', 'none'), 'none'); + Assert::same($env->get('#E', 'none'), 'none'); + Assert::same($env->get('F'), ''); + Assert::same($env->get('G'), 'xax'); + Assert::same($env->get('H'), "\"mixed'"); + Assert::same($env->get('I'), 'x'); + } + + public function sharedInstanceIsLoadedOnce(): void + { + Assert::same(Env::load(), Env::load()); + } + + public function defaultsWinOverTheFallback(): void + { + Assert::same((new Env(['CYCLE_TESTING_PROBE' => 'default']))->get('CYCLE_TESTING_PROBE', 'fallback'), 'default'); + Assert::same((new Env())->get('CYCLE_TESTING_PROBE', 'fallback'), 'fallback'); + } + + public function everyDriverByDefault(): void + { + Assert::same((new Env())->drivers(), Driver::cases()); + } + + /** + * In a child process: the deprecation notice goes to the real STDERR, which Infection's run of the + * suite does not tolerate. + */ + public function legacyDbVariableNamesTheDriver(): void + { + $code = \sprintf( + 'require %s; echo implode(",", array_column((new %s())->drivers(), "value"));', + \var_export(\dirname(__DIR__, 2) . '/vendor/autoload.php', true), + Env::class, + ); + $process = \proc_open( + [\PHP_BINARY, '-r', $code], + [1 => ['pipe', 'w'], 2 => ['pipe', 'w']], + $pipes, + null, + ['DB' => 'mysql'] + \array_diff_key(\getenv(), ['DB_DRIVERS' => true]), + ); + $out = \stream_get_contents($pipes[1]); + $err = \stream_get_contents($pipes[2]); + \proc_close($process); + + Assert::same($out, 'mysql'); + Assert::same($err, "cycle/testing: `DB` is deprecated, use `DB_DRIVERS`.\n"); + } + + public function dbDriversWinsOverTheLegacyVariable(): void + { + \putenv('DB=mysql'); + \putenv('DB_DRIVERS=sqlite'); + + Assert::same((new Env())->drivers(), [Driver::SQLite]); + } + + public function emptyLegacyVariableIsIgnored(): void + { + \putenv('DB='); + + Assert::same((new Env(['DB_DRIVERS' => 'postgres']))->drivers(), [Driver::Postgres]); + } + + public function unknownDriverFails(): never + { + \putenv('DB_DRIVERS=sqlite,oracle'); + + Expect::exception(\InvalidArgumentException::class)->withMessage('Unknown driver `oracle` in DB_DRIVERS.'); + + (new Env())->drivers(); } public function environmentWinsOverDefaultsAndOverridesWinOverBoth(): void @@ -62,7 +150,7 @@ public function missingKeyThrows(): never public function driversFromList(): void { - \putenv('DB_DRIVERS= MySQL, sqlite,mysql'); + \putenv('DB_DRIVERS= MySQL, mysql,sqlite'); Assert::same((new Env())->drivers(), [Driver::MySQL, Driver::SQLite]); } From 68cf22645dd0f78844bae5728aff773af2c8903a Mon Sep 17 00:00:00 2001 From: roxblnfk Date: Fri, 20 Nov 2026 21:12:07 +0400 Subject: [PATCH 6/9] test(database): cover the connection pool, table rendering, builder and purger Assisted-By: Claude Opus 5.5 --- tests/Feature/Common/DatabaseContextTest.php | 1 + tests/Feature/Common/PurgerTest.php | 2 + tests/Unit/ConnectionPoolTest.php | 81 ++++++++++++++++++ tests/Unit/PurgerTest.php | 70 ++++++++++++++++ tests/Unit/TableBuilderTest.php | 27 ++++++ tests/Unit/TableRendererTest.php | 88 ++++++++++++++++++++ 6 files changed, 269 insertions(+) create mode 100644 tests/Unit/PurgerTest.php create mode 100644 tests/Unit/TableRendererTest.php diff --git a/tests/Feature/Common/DatabaseContextTest.php b/tests/Feature/Common/DatabaseContextTest.php index 31aa141..58a18f3 100644 --- a/tests/Feature/Common/DatabaseContextTest.php +++ b/tests/Feature/Common/DatabaseContextTest.php @@ -70,6 +70,7 @@ public function tableBuilderMatchesDatabase(): void $schema = $this->schema('child'); Assert::true($schema->exists()); Assert::true($schema->hasForeignKey(['parent_id'])); + Assert::true($schema->hasIndex(['note'])); SchemaAssert::sameAsInDb($schema); } diff --git a/tests/Feature/Common/PurgerTest.php b/tests/Feature/Common/PurgerTest.php index 170c84b..1972e45 100644 --- a/tests/Feature/Common/PurgerTest.php +++ b/tests/Feature/Common/PurgerTest.php @@ -21,6 +21,8 @@ public function dropsTablesLinkedByForeignKeysBothWays(): void $this->makeFK('author', 'book_id', 'book', 'id', ForeignKeyInterface::NO_ACTION, ForeignKeyInterface::NO_ACTION); $this->database->table('author')->insertOne(['book_id' => null]); $this->database->table('book')->insertOne(['author_id' => 1]); + Assert::true($this->schema('book')->hasForeignKey(['author_id'])); + Assert::true($this->schema('author')->hasForeignKey(['book_id'])); Purger::dropTables($this->database->getDriver()); diff --git a/tests/Unit/ConnectionPoolTest.php b/tests/Unit/ConnectionPoolTest.php index 30de0b2..017198c 100644 --- a/tests/Unit/ConnectionPoolTest.php +++ b/tests/Unit/ConnectionPoolTest.php @@ -7,7 +7,10 @@ use Cycle\Database\DatabaseManager; use Cycle\Testing\Database\ConnectionPool; use Cycle\Testing\Database\Driver; +use Cycle\Testing\Database\Env; use Cycle\Testing\Database\Layout; +use Cycle\Testing\Database\Mock\SQLiteWrapDriver; +use Cycle\Testing\Database\QueryLog; use Testo\Assert; use Testo\Test; @@ -37,6 +40,84 @@ public function databasesOnOneConnectionShareTheName(): void Assert::same(self::driverName($pool->manager(), 'secondary'), 'default'); } + public function driversAreMemoisedByTheirOptions(): void + { + $pool = new ConnectionPool(Driver::SQLite); + + Assert::same($pool->driver(), $pool->driver()); + Assert::notSame($pool->driver(connectionOptions: ['options' => [\PDO::ATTR_TIMEOUT => 5]]), $pool->driver()); + Assert::array($pool->drivers())->isList()->hasCount(2); + } + + public function managersAreMemoisedPerWrapMode(): void + { + $pool = new ConnectionPool(Driver::SQLite, Layout::withSqlite(['secondary'])); + + $plain = $pool->manager(); + $wrapped = $pool->manager(wrap: true); + + Assert::same($pool->manager(), $plain); + Assert::same($pool->managers(), [$plain, $wrapped]); + Assert::instanceOf($wrapped->database()->getDriver(), SQLiteWrapDriver::class); + Assert::false($plain->database()->getDriver() instanceof SQLiteWrapDriver); + Assert::same($wrapped->database('secondary')->getDriver(), $plain->database('secondary')->getDriver()); + } + + public function ownSqliteDatabasesLogInterpolatedQueries(): void + { + $log = new QueryLog(); + $database = (new ConnectionPool(Driver::SQLite, Layout::withSqlite(['secondary']), queryLog: $log))->manager()->database('secondary'); + $database->execute('CREATE TABLE t (id INTEGER)'); + + $database->select()->from('t')->where('id', 42)->fetchAll(); + + Assert::string(\implode("\n", $log->queries()))->contains('42'); + } + + public function driverOptionsMergeIntoTheDefaults(): void + { + $log = new QueryLog(); + $driver = (new ConnectionPool(Driver::SQLite, queryLog: $log))->driver(driverOptions: [ + 'options' => ['withDatetimeMicroseconds' => true], + 'readonly' => true, + ]); + + $driver->query('SELECT ? AS at', [new \DateTimeImmutable('2024-01-02 03:04:05.123456', new \DateTimeZone('UTC'))])->fetchAll(); + + Assert::true($driver->isReadonly()); + Assert::string(\implode("\n", $log->queries()))->contains("'2024-01-02 03:04:05.123456'"); + } + + public function connectionOptionsReplaceTheConnectionSettings(): void + { + $file = \sys_get_temp_dir() . '/cycle-testing-pool-' . \bin2hex(\random_bytes(4)) . '.sqlite'; + $pool = new ConnectionPool(Driver::SQLite); + + try { + $pool->driver(connectionOptions: ['database' => $file])->execute('CREATE TABLE t (id INTEGER)'); + + Assert::true(\is_file($file)); + Assert::false($pool->driver()->getSchemaHandler()->hasTable('t')); + } finally { + $pool->disconnect(); + @\unlink($file); + } + } + + public function memoryOnlyForInMemorySqlite(): void + { + Assert::true((new ConnectionPool(Driver::SQLite, env: new Env(['DB_SQLITE_FILE' => ''])))->isMemory()); + Assert::false((new ConnectionPool(Driver::SQLite, env: new Env(['DB_SQLITE_FILE' => 'runtime/x.db'])))->isMemory()); + Assert::false((new ConnectionPool(Driver::MySQL, env: Env::load()))->isMemory()); + } + + public function envIsTheGivenOne(): void + { + $env = new Env(); + + Assert::same((new ConnectionPool(Driver::SQLite, env: $env))->env, $env); + } + private static function driverName(DatabaseManager $manager, string $database): string { return $manager->database($database)->getDriver()->getName(); diff --git a/tests/Unit/PurgerTest.php b/tests/Unit/PurgerTest.php new file mode 100644 index 0000000..74a46dc --- /dev/null +++ b/tests/Unit/PurgerTest.php @@ -0,0 +1,70 @@ +getTables(), []); + } + + public function dropTablesDropsEachTableWithTheChecksOff(): void + { + $log = new QueryLog(); + $database = self::referencedRows(Memory::manager(log: $log)->database()); + + $run = $log->capture(static fn() => Purger::dropTables($database->getDriver())); + + Assert::same(\array_slice($run['queries'], 1), [ + 'PRAGMA foreign_keys = OFF', + 'DROP TABLE "a_parent"', + 'DROP TABLE "b_child"', + 'PRAGMA foreign_keys = ON', + ]); + Assert::same($database->getTables(), []); + Assert::same($database->query('PRAGMA foreign_keys')->fetchColumn(), 1); + } + + public function dropTablesOnAnEmptyDatabaseOnlyLists(): void + { + $log = new QueryLog(); + $database = Memory::manager(log: $log)->database(); + + $run = $log->capture(static fn() => Purger::dropTables($database->getDriver())); + + Assert::count($run['queries'], 1); + } + + /** + * `b_child` references `a_parent`, both have a row, and foreign keys are enforced. + */ + private static function referencedRows(Database $database): Database + { + $database->execute('PRAGMA foreign_keys = ON'); + $builder = new TableBuilder($database); + $builder->makeTable('a_parent', ['id' => 'primary']); + $builder->makeTable('b_child', ['id' => 'primary', 'parent_id' => 'integer'], fk: [ + 'parent_id' => ['table' => 'a_parent', 'column' => 'id', 'onDelete' => 'NO ACTION'], + ]); + $database->insert('a_parent')->values(['id' => 1])->run(); + $database->insert('b_child')->values(['id' => 1, 'parent_id' => 1])->run(); + + return $database; + } +} diff --git a/tests/Unit/TableBuilderTest.php b/tests/Unit/TableBuilderTest.php index 3902964..0af49d1 100644 --- a/tests/Unit/TableBuilderTest.php +++ b/tests/Unit/TableBuilderTest.php @@ -53,6 +53,33 @@ public function foreignKeysAndPurge(): void Assert::same($db->getTables(), []); } + public function foreignKeyFromAnotherColumnWithItsRules(): void + { + $db = Memory::database(); + $builder = new TableBuilder($db); + $builder->makeTable('parent', ['id' => 'primary']); + $builder->makeTable('child', ['id' => 'primary', 'parent_id' => 'integer, nullable'], fk: [ + ['table' => 'parent', 'column' => 'id', 'from' => 'parent_id', 'onDelete' => 'SET NULL', 'onUpdate' => 'NO ACTION'], + ]); + + $key = $db->table('child')->getSchema()->foreignKey(['parent_id']); + Assert::same($key->getDeleteRule(), 'SET NULL'); + Assert::same($key->getUpdateRule(), 'NO ACTION'); + } + + public function makeFkAddsAKeyToAnExistingTable(): void + { + $db = Memory::database(); + $builder = new TableBuilder($db); + $builder->makeTable('parent', ['id' => 'primary']); + $builder->makeTable('child', ['id' => 'primary', 'parent_id' => 'integer']); + + $builder->makeFK('child', 'parent_id', 'parent', 'id', onDelete: 'NO ACTION'); + + Assert::true($db->table('child')->getSchema()->hasForeignKey(['parent_id'])); + Assert::same($db->table('child')->getSchema()->foreignKey(['parent_id'])->getDeleteRule(), 'NO ACTION'); + } + public function invalidTypeFails(): never { Expect::exception(SchemaException::class); diff --git a/tests/Unit/TableRendererTest.php b/tests/Unit/TableRendererTest.php new file mode 100644 index 0000000..33aa06c --- /dev/null +++ b/tests/Unit/TableRendererTest.php @@ -0,0 +1,88 @@ + 'integer', + 'f' => 'float', + 'b' => 'boolean', + 's' => 'string', + 'at' => 'datetime', + 'day' => 'date', + 'e' => 'enum(on, off)', + ]); + + Assert::same($table->column('i')->getDefaultValue(), 0); + Assert::same($table->column('f')->getDefaultValue(), 0.0); + Assert::same($table->column('b')->getDefaultValue(), false); + Assert::same($table->column('s')->getDefaultValue(), ''); + Assert::instanceOf($table->column('at')->getDefaultValue(), \DateTimeInterface::class); + Assert::same($table->column('at')->getDefaultValue()->format('Y-m-d H:i:s'), '1970-01-01 00:00:00'); + Assert::same($table->column('day')->getDefaultValue(), '1970-01-01'); + Assert::same($table->column('e')->getDefaultValue(), 'on'); + } + + public function primaryAndRequiredColumnsGetNoDefault(): void + { + $table = self::render(['id' => 'primary', 'name' => 'string, required', 'code' => 'string(8), primary']); + + Assert::null($table->column('id')->getDefaultValue()); + Assert::null($table->column('name')->getDefaultValue()); + Assert::null($table->column('code')->getDefaultValue()); + } + + public function primaryFlagMakesTheKey(): void + { + $table = self::render(['a' => 'integer, primary', 'b' => 'string(8), primary', 'c' => 'string']); + + Assert::same($table->getPrimaryKeys(), ['a', 'b']); + } + + public function nullDefaultMakesTheColumnNullable(): void + { + $table = self::render(['n' => 'string', 'v' => 'string'], ['n' => null, 'v' => 'x']); + + Assert::true($table->column('n')->isNullable()); + Assert::false($table->column('v')->isNullable()); + Assert::same($table->column('v')->getDefaultValue(), 'x'); + } + + public function typeIsCaseInsensitive(): void + { + $table = self::render(['name' => 'STRING(10)']); + + Assert::same($table->column('name')->getSize(), 10); + } + + public function onlyWholeNumbersBecomeSizes(): void + { + $table = self::render(['e' => 'enum(1a, a1, 2)']); + + Assert::same($table->column('e')->getEnumValues(), ['1a', 'a1', '2']); + } + + /** + * @param array $columns + * @param array $defaults + */ + private static function render(array $columns, array $defaults = []): AbstractTable + { + $table = Memory::database()->table('t')->getSchema(); + (new TableRenderer())->renderColumns($table, $columns, $defaults); + + return $table; + } +} From 3c11e238d5bb6ec23fc2b5a2c4f6669ea47a668c Mon Sep 17 00:00:00 2001 From: roxblnfk Date: Fri, 20 Nov 2026 21:15:01 +0400 Subject: [PATCH 7/9] test(database): cover drivers, features, driver filters, layout, the query log and the wrap driver test(orm): cover the ORM factory defaults and schema source reuse Assisted-By: Claude Opus 5.5 --- tests/Feature/Common/QueryCountersTest.php | 18 +++++++ tests/Feature/Common/WrapDriverTest.php | 11 +++++ tests/Unit/DriverFilterTest.php | 32 ++++++++++++ tests/Unit/DriverTest.php | 40 +++++++++++++++ tests/Unit/LayoutTest.php | 22 +++++++++ tests/Unit/OrmFactoryTest.php | 57 ++++++++++++++++++++++ tests/Unit/QueryLogTest.php | 37 ++++++++++++++ 7 files changed, 217 insertions(+) create mode 100644 tests/Unit/DriverFilterTest.php create mode 100644 tests/Unit/OrmFactoryTest.php diff --git a/tests/Feature/Common/QueryCountersTest.php b/tests/Feature/Common/QueryCountersTest.php index 18d1bb6..4c58c58 100644 --- a/tests/Feature/Common/QueryCountersTest.php +++ b/tests/Feature/Common/QueryCountersTest.php @@ -7,6 +7,8 @@ use Cycle\Testing\Database\Assert\QueryAssert; use Cycle\Testing\Database\DatabaseTestCase; use Cycle\Testing\Database\QueryLog; +use Testo\Assert\State\Assertion\AssertionException; +use Testo\Expect; use Testo\Lifecycle\BeforeTest; use Testo\Test; @@ -56,4 +58,20 @@ public function queryAssertPrefersTheGivenLog(): void QueryAssert::count(0, 1, fn() => $log->info('DELETE FROM t', ['elapsed' => 0.1]), $log); } + + public function readCountMismatchFails(): never + { + $this->captureReadQueries(); + + Expect::exception(AssertionException::class)->withMessageContaining('Number of read SQL queries do not match, expected 1 got 0.'); + + $this->assertNumReads(1); + } + + public function wrapDriverNeedsTheAttribute(): never + { + Expect::exception(\LogicException::class)->withMessageContaining('WrapDriver'); + + $this->wrapDriver(); + } } diff --git a/tests/Feature/Common/WrapDriverTest.php b/tests/Feature/Common/WrapDriverTest.php index edee1bb..740c741 100644 --- a/tests/Feature/Common/WrapDriverTest.php +++ b/tests/Feature/Common/WrapDriverTest.php @@ -24,6 +24,17 @@ public function countsDisconnects(): void $driver->disconnect(); Assert::same($driver->disconnectCalls, 1); + Assert::false($driver->isConnected()); + } + + public function oneFailedBeginIsRetried(): void + { + $this->wrapDriver()->exceptionOnTransactionBegin = 1; + + $this->database->begin(); + + Assert::same($this->database->getDriver()->getTransactionLevel(), 1); + $this->database->rollback(); } public function knobsAreResetBetweenTests(): void diff --git a/tests/Unit/DriverFilterTest.php b/tests/Unit/DriverFilterTest.php new file mode 100644 index 0000000..ea6a282 --- /dev/null +++ b/tests/Unit/DriverFilterTest.php @@ -0,0 +1,32 @@ +drivers, [Driver::MySQL, Driver::Postgres, Driver::SQLServer]); + Assert::false($filter->allows(Driver::SQLite)); + } + + public function exceptDriverRejectsEveryListedDriver(): void + { + $filter = new ExceptDriver(Driver::MySQL, Driver::Postgres, Driver::SQLServer); + + Assert::same($filter->drivers, [Driver::MySQL, Driver::Postgres, Driver::SQLServer]); + Assert::true($filter->allows(Driver::SQLite)); + Assert::false($filter->allows(Driver::SQLServer)); + } +} diff --git a/tests/Unit/DriverTest.php b/tests/Unit/DriverTest.php index abe33f3..631e17f 100644 --- a/tests/Unit/DriverTest.php +++ b/tests/Unit/DriverTest.php @@ -5,12 +5,17 @@ namespace Cycle\Testing\Tests\Unit; use Cycle\Database\Config\MySQLDriverConfig; +use Cycle\Database\Config\Postgres\TcpConnectionConfig as PostgresConnection; use Cycle\Database\Config\SQLite\FileConnectionConfig; use Cycle\Database\Config\SQLite\MemoryConnectionConfig; +use Cycle\Database\Config\SQLServer\TcpConnectionConfig as SQLServerConnection; use Cycle\Testing\Database\Driver; use Cycle\Testing\Database\Env; use Cycle\Testing\Database\Feature; use Cycle\Testing\Database\Mock\MySQLWrapDriver; +use Cycle\Testing\Database\Mock\PostgresWrapDriver; +use Cycle\Testing\Database\Mock\SQLiteWrapDriver; +use Cycle\Testing\Database\Mock\SQLServerWrapDriver; use Testo\Assert; use Testo\Expect; use Testo\Test; @@ -56,6 +61,41 @@ public function supportsFeatures(): void Assert::false(Driver::MySQL->supports(Feature::TransactionalDdl)); } + public function featureMatrix(): void + { + $matrix = []; + foreach (Feature::cases() as $feature) { + $matrix[$feature->name] = \array_column($feature->drivers(), 'value'); + } + + Assert::same($matrix, [ + 'Returning' => ['sqlite', 'postgres', 'sqlserver'], + 'FullJoin' => ['postgres', 'sqlserver'], + 'ForUpdate' => ['mysql', 'postgres', 'sqlserver'], + 'Schemas' => ['postgres', 'sqlserver'], + 'TransactionalDdl' => ['sqlite', 'postgres'], + ]); + } + + public function everyDriverHasItsConfigAndWrapDriver(): void + { + $env = Env::load(); + + Assert::instanceOf(Driver::Postgres->config($env)->connection, PostgresConnection::class); + Assert::instanceOf(Driver::SQLServer->config($env)->connection, SQLServerConnection::class); + Assert::same(Driver::SQLite->wrapDriverClass(), SQLiteWrapDriver::class); + Assert::same(Driver::MySQL->wrapDriverClass(), MySQLWrapDriver::class); + Assert::same(Driver::Postgres->wrapDriverClass(), PostgresWrapDriver::class); + Assert::same(Driver::SQLServer->wrapDriverClass(), SQLServerWrapDriver::class); + } + + public function serverConnectionsTimeOutQuickly(): void + { + $options = Driver::MySQL->config(Env::load())->connection->getOptions(); + + Assert::same($options[\PDO::ATTR_TIMEOUT], (string) Driver::CONNECT_TIMEOUT); + } + public function configReadsEnv(): void { $env = new Env(['DB_MYSQL_HOST' => 'db', 'DB_MYSQL_PORT' => '3333', 'DB_MYSQL_DATABASE' => 'x', 'DB_MYSQL_USER' => 'u', 'DB_MYSQL_PASSWORD' => 'p']); diff --git a/tests/Unit/LayoutTest.php b/tests/Unit/LayoutTest.php index ab64634..1227954 100644 --- a/tests/Unit/LayoutTest.php +++ b/tests/Unit/LayoutTest.php @@ -7,6 +7,7 @@ use Cycle\Testing\Database\Layout; use Cycle\Testing\Database\Memory; use Testo\Assert; +use Testo\Expect; use Testo\Test; #[Test] @@ -35,4 +36,25 @@ public function defaultCanBePrefixed(): void Assert::same($layout->prefix('default'), 'tests_'); Assert::false($layout->isSqlite('slave')); } + + public function defaultCannotHaveItsOwnSqlite(): never + { + Expect::exception(\InvalidArgumentException::class)->withMessage('`default` always uses the suite driver.'); + + Layout::withSqlite(['default']); + } + + public function unknownDatabaseHasNoPrefix(): never + { + Expect::exception(\OutOfBoundsException::class)->withMessage('No database `nope`.'); + + Layout::single()->prefix('nope'); + } + + public function unknownDatabaseHasNoConnection(): never + { + Expect::exception(\OutOfBoundsException::class)->withMessage('No database `nope`.'); + + Layout::single()->isSqlite('nope'); + } } diff --git a/tests/Unit/OrmFactoryTest.php b/tests/Unit/OrmFactoryTest.php new file mode 100644 index 0000000..48d36d3 --- /dev/null +++ b/tests/Unit/OrmFactoryTest.php @@ -0,0 +1,57 @@ +getFactory()->collection(), DoctrineCollectionFactory::class); + Assert::instanceOf($orm->getFactory()->collection('array'), ArrayCollectionFactory::class); + $options = $orm->getService(Options::class); + Assert::true($options->ignoreUninitializedRelations); + Assert::true($options->groupByToDeduplicate); + } + + public function givenOptionsReplaceTheDefaults(): void + { + $options = new Options(); + + $orm = Memory::orm(UserSchema::schema(), factory: new OrmFactory(options: $options)); + \assert($orm instanceof ORM); + + Assert::same($orm->getService(Options::class), $options); + } + + public function schemaSourceResolvesOncePerLayout(): void + { + $source = SchemaSource::of(UserSchema::schema()); + + Assert::same($source->resolve(), $source->resolve()); + Assert::true($source->resolve()->defines('user')); + } + + public function schemaObjectIsUsedAsIs(): void + { + $schema = SchemaSource::of(UserSchema::schema())->resolve(); + + Assert::same(SchemaSource::of($schema)->resolve(), $schema); + } +} diff --git a/tests/Unit/QueryLogTest.php b/tests/Unit/QueryLogTest.php index ea524f3..8fe872b 100644 --- a/tests/Unit/QueryLogTest.php +++ b/tests/Unit/QueryLogTest.php @@ -7,6 +7,7 @@ use Cycle\Testing\Database\Assert\QueryAssert; use Cycle\Testing\Database\Memory; use Cycle\Testing\Database\QueryLog; +use Psr\Log\AbstractLogger; use Testo\Assert; use Testo\Test; @@ -64,6 +65,42 @@ public function captureReportsTheDifference(): void Assert::same($run['queries'], ['DELETE FROM t']); } + public function forwardsEveryMessageAsALine(): void + { + $forward = new class extends AbstractLogger { + /** @var list */ + public array $lines = []; + + public function log($level, string|\Stringable $message, array $context = []): void + { + $this->lines[] = (string) $message; + } + }; + $log = new QueryLog(); + $log->forwardTo($forward); + + $log->info(new class implements \Stringable { + public function __toString(): string + { + return 'SELECT 1'; + } + }, ['elapsed' => 0.1]); + $log->info('Begin transaction'); + + Assert::same($forward->lines, ["SELECT 1\n", "Begin transaction\n"]); + Assert::same($log->queries(), ['SELECT 1']); + } + + public function postgresCatalogQueriesAreNotCounted(): void + { + $log = new QueryLog(); + foreach (['tc.constraint_name', 'pg_indexes', 'pg_constraint', 'information_schema', 'pg_class'] as $marker) { + $log->info("SELECT {$marker} FROM x", ['elapsed' => 0.1]); + } + + Assert::same($log->countReads(), 0); + } + public function queryAssertOnRealDriver(): void { $log = new QueryLog(); From 58e6cff16b8ea2911f50be889205d9cf387ab589 Mon Sep 17 00:00:00 2001 From: roxblnfk Date: Fri, 20 Nov 2026 22:26:08 +0400 Subject: [PATCH 8/9] test(orm): cover the class list filter Assisted-By: Claude Opus 5.5 --- tests/Unit/ClassListTest.php | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 tests/Unit/ClassListTest.php diff --git a/tests/Unit/ClassListTest.php b/tests/Unit/ClassListTest.php new file mode 100644 index 0000000..3ca4b96 --- /dev/null +++ b/tests/Unit/ClassListTest.php @@ -0,0 +1,31 @@ +getClasses()), [User::class, ShadowingEntity::class]); + } + + public function targetKeepsTheClassAndItsSubclasses(): void + { + $list = new ClassList(User::class, ShadowedParent::class, ShadowingEntity::class); + + Assert::same(\array_keys($list->getClasses(ShadowedParent::class)), [ShadowedParent::class, ShadowingEntity::class]); + Assert::same(\array_keys($list->getClasses(ShadowingEntity::class)), [ShadowingEntity::class]); + } +} From ab0452089d5a8eedb451444bd18cb67b4a360a9b Mon Sep 17 00:00:00 2001 From: roxblnfk Date: Fri, 20 Nov 2026 22:26:09 +0400 Subject: [PATCH 9/9] ci: raise the mutation score gate The ignored mutants change nothing observable: the attributes fetched with limit 1 are not repeatable, connections() is only iterated, and comparing the classes of a non-object throws an Error that equals() already turns into false. Assisted-By: Claude Opus 5.5 --- infection.json | 22 ++++++++++++++++++++-- 1 file changed, 20 insertions(+), 2 deletions(-) diff --git a/infection.json b/infection.json index c0c2a5a..a6e0b1b 100644 --- a/infection.json +++ b/infection.json @@ -6,13 +6,31 @@ ] }, "timeout": 10, - "minMsi": 54, - "minCoveredMsi": 54, + "minMsi": 90, + "minCoveredMsi": 90, "testFramework": "testo", "tmpDir": "runtime", "logs": { "stryker": { "report": "1.x" } + }, + "mutators": { + "@default": true, + "IncrementInteger": { + "ignoreSourceCodeByRegex": [ + ".*limit: 1.*" + ] + }, + "LogicalAnd": { + "ignoreSourceCodeByRegex": [ + ".*\\$a::class === \\$b::class && \\$a == \\$b.*" + ] + }, + "UnwrapArrayValues": { + "ignore": [ + "Cycle\\Testing\\Database\\Internal\\DatabaseInterceptor::connections" + ] + } } }