@shanyucoder/flowgrid 0.1.0

package/adapters/laravel/php/src/WorkspaceInspector.php

@@ -0,0 +1,240 @@
+<?php
+
+declare(strict_types=1);
+
+namespace FlowGrid\Laravel\UnitGen;
+
+final class WorkspaceInspector
+{
+    /**
+     * @param  array{module: string, entity: string, pathModel?: string}  $ctx
+     * @return array<string, string>
+     */
+    public static function resolveUnitPaths(array $ctx, string $repoRoot): array
+    {
+        $moduleRoot = $repoRoot.DIRECTORY_SEPARATOR.'Modules'.DIRECTORY_SEPARATOR.$ctx['module'];
+
+        return [
+            'moduleRoot' => $moduleRoot,
+            'supportDir' => $moduleRoot.DIRECTORY_SEPARATOR.'Tests'.DIRECTORY_SEPARATOR.'Support',
+            'requestsDir' => $moduleRoot.DIRECTORY_SEPARATOR.'Http'.DIRECTORY_SEPARATOR.'Requests',
+            'controllerInvokeTest' => $moduleRoot.DIRECTORY_SEPARATOR.'Tests'.DIRECTORY_SEPARATOR.'Feature'.DIRECTORY_SEPARATOR.'Http'.DIRECTORY_SEPARATOR.'Controllers'.DIRECTORY_SEPARATOR.$ctx['entity'].'ControllerInvokeTest.php',
+            'controllerTest' => $moduleRoot.DIRECTORY_SEPARATOR.'Tests'.DIRECTORY_SEPARATOR.'Feature'.DIRECTORY_SEPARATOR.'Http'.DIRECTORY_SEPARATOR.'Controllers'.DIRECTORY_SEPARATOR.$ctx['entity'].'ControllerTest.php',
+            'actionTest' => $moduleRoot.DIRECTORY_SEPARATOR.'Tests'.DIRECTORY_SEPARATOR.'Unit'.DIRECTORY_SEPARATOR.'Http'.DIRECTORY_SEPARATOR.'Actions'.DIRECTORY_SEPARATOR.$ctx['entity'].'ActionTest.php',
+            'queryTest' => $moduleRoot.DIRECTORY_SEPARATOR.'Tests'.DIRECTORY_SEPARATOR.'Unit'.DIRECTORY_SEPARATOR.'Http'.DIRECTORY_SEPARATOR.'Queries'.DIRECTORY_SEPARATOR.$ctx['entity'].'QueryTest.php',
+            'resourceTest' => $moduleRoot.DIRECTORY_SEPARATOR.'Tests'.DIRECTORY_SEPARATOR.'Unit'.DIRECTORY_SEPARATOR.'Http'.DIRECTORY_SEPARATOR.'Resources'.DIRECTORY_SEPARATOR.$ctx['entity'].'ResourceTest.php',
+            'exercisesHooks' => $moduleRoot.DIRECTORY_SEPARATOR.'Tests'.DIRECTORY_SEPARATOR.'Support'.DIRECTORY_SEPARATOR.'ExercisesRequestValidationHooks.php',
+            'controllerInvoker' => $moduleRoot.DIRECTORY_SEPARATOR.'Tests'.DIRECTORY_SEPARATOR.'Support'.DIRECTORY_SEPARATOR.'ControllerMethodInvoker.php',
+        ];
+    }
+
+    /** @return list<string> */
+    public static function listModuleRequestClasses(string $requestsDir, string $module): array
+    {
+        if (!is_dir($requestsDir)) {
+            return [];
+        }
+
+        $baseNames = [$module.'Request' => true, $module.'SearchRequest' => true];
+        $classes = [];
+        foreach (scandir($requestsDir) ?: [] as $name) {
+            if (!str_ends_with($name, '.php')) {
+                continue;
+            }
+            $className = substr($name, 0, -4);
+            if (isset($baseNames[$className])) {
+                continue;
+            }
+            $classes[] = $className;
+        }
+        sort($classes);
+
+        return $classes;
+    }
+
+    /** @return array{fqcn: string, className: string} */
+    public static function inferModuleBaseRequest(string $moduleRoot, string $module): array
+    {
+        $searchPath = $moduleRoot.DIRECTORY_SEPARATOR.'Http'.DIRECTORY_SEPARATOR.'Requests'.DIRECTORY_SEPARATOR.$module.'SearchRequest.php';
+        $requestPath = $moduleRoot.DIRECTORY_SEPARATOR.'Http'.DIRECTORY_SEPARATOR.'Requests'.DIRECTORY_SEPARATOR.$module.'Request.php';
+
+        if (is_file($searchPath)) {
+            return [
+                'fqcn' => "Modules\\{$module}\\Http\\Requests\\{$module}SearchRequest",
+                'className' => $module.'SearchRequest',
+            ];
+        }
+        if (is_file($requestPath)) {
+            return [
+                'fqcn' => "Modules\\{$module}\\Http\\Requests\\{$module}Request",
+                'className' => $module.'Request',
+            ];
+        }
+
+        return [
+            'fqcn' => 'App\\Http\\Requests\\SearchRequest',
+            'className' => 'SearchRequest',
+        ];
+    }
+
+    /** @param array<string, mixed> $spec @return list<string> */
+    public static function collectRequirementIds(array $spec): array
+    {
+        $ids = [];
+        foreach ($spec['requirements']['covered'] ?? [] as $id) {
+            $ids[] = (string) $id;
+        }
+
+        return array_values(array_filter($ids));
+    }
+
+    /** @param array<string, mixed> $spec */
+    public static function entityHasRelationships(array $spec, string $entity): bool
+    {
+        foreach ($spec['modules'] ?? [] as $mod) {
+            foreach ($mod['entities'] ?? [] as $ent) {
+                if (($ent['name'] ?? null) === $entity && !empty($ent['relationships'])) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    /** @param array<string, mixed> $spec */
+    public static function entityHasChainScope(array $spec, string $entity): bool
+    {
+        foreach ($spec['modules'] ?? [] as $mod) {
+            foreach ($mod['entities'] ?? [] as $ent) {
+                if (($ent['name'] ?? null) === $entity && !empty($ent['scope']['bySession'])) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * @param  array<string, mixed>|null  $manifest
+     * @return array{satisfied: bool, reason: ?string}
+     */
+    public static function structuralTestsSatisfiedByCodegen(?array $manifest): array
+    {
+        if ($manifest === null) {
+            return ['satisfied' => false, 'reason' => null];
+        }
+
+        foreach ($manifest['execution'] ?? [] as $entry) {
+            if (($entry['id'] ?? null) === 'module-test' && in_array((string) ($entry['status'] ?? ''), ['OK', 'SKIPPED'], true)) {
+                return [
+                    'satisfied' => true,
+                    'reason' => 'codegen.manifest execution: module-test '.$entry['status'],
+                ];
+            }
+        }
+
+        foreach ($manifest['skipped'] ?? [] as $entry) {
+            if (($entry['id'] ?? null) === 'module-test') {
+                return [
+                    'satisfied' => true,
+                    'reason' => 'codegen.manifest skipped: module-test ('.($entry['reason'] ?? 'already exists').')',
+                ];
+            }
+        }
+
+        foreach ($manifest['tagPlan'] ?? [] as $entry) {
+            if (($entry['tag'] ?? null) === '#gen:test-module' && ($entry['status'] ?? null) === 'skipped') {
+                return [
+                    'satisfied' => true,
+                    'reason' => 'codegen.manifest tagPlan: #gen:test-module skipped',
+                ];
+            }
+        }
+
+        return ['satisfied' => false, 'reason' => null];
+    }
+
+    /**
+     * @param  array{module: string, entity: string}  $ctx
+     * @return array{satisfied: bool, reason: ?string}
+     */
+    public static function structuralTestsSatisfiedByWorkspace(array $ctx, string $repoRoot): array
+    {
+        $paths = self::resolveUnitPaths($ctx, $repoRoot);
+        $layers = [
+            ['prod' => 'Http/Controllers/'.$ctx['entity'].'Controller.php', 'test' => $paths['controllerTest']],
+            ['prod' => 'Http/Actions/'.$ctx['entity'].'Action.php', 'test' => $paths['actionTest']],
+            ['prod' => 'Http/Queries/'.$ctx['entity'].'Query.php', 'test' => $paths['queryTest']],
+            ['prod' => 'Http/Resources/'.$ctx['entity'].'Resource.php', 'test' => $paths['resourceTest']],
+        ];
+
+        $required = 0;
+        $present = 0;
+        foreach ($layers as $layer) {
+            $prodPath = $paths['moduleRoot'].DIRECTORY_SEPARATOR.str_replace('/', DIRECTORY_SEPARATOR, $layer['prod']);
+            if (!is_file($prodPath)) {
+                continue;
+            }
+            $required++;
+            if (is_file($layer['test'])) {
+                $present++;
+            }
+        }
+
+        if (is_dir($paths['requestsDir'])) {
+            $entityPrefix = $ctx['entity'];
+            foreach (scandir($paths['requestsDir']) ?: [] as $name) {
+                if (!str_ends_with($name, '.php')) {
+                    continue;
+                }
+                $className = substr($name, 0, -4);
+                if (!str_starts_with($className, $entityPrefix)) {
+                    continue;
+                }
+                $testPath = $paths['moduleRoot'].DIRECTORY_SEPARATOR.'Tests'.DIRECTORY_SEPARATOR.'Unit'.DIRECTORY_SEPARATOR.'Http'.DIRECTORY_SEPARATOR.'Requests'.DIRECTORY_SEPARATOR.$className.'Test.php';
+                $required++;
+                if (is_file($testPath)) {
+                    $present++;
+                }
+            }
+        }
+
+        if ($required > 0 && $present === $required) {
+            return [
+                'satisfied' => true,
+                'reason' => "workspace: structural tests {$present}/{$required} for {$ctx['entity']}",
+            ];
+        }
+
+        return ['satisfied' => false, 'reason' => null];
+    }
+
+    /**
+     * @param  array<string, mixed>  $ctx
+     * @param  array{explicitGen?: bool}  $options
+     * @return array{skip: bool, reason: ?string}
+     */
+    public static function shouldSkipModuleTestStub(array $ctx, array $options = []): array
+    {
+        if (($ctx['phase'] ?? '') === 'stub') {
+            return ['skip' => false, 'reason' => null];
+        }
+        if (!empty($options['explicitGen'])) {
+            return ['skip' => false, 'reason' => null];
+        }
+
+        $fromCodegen = self::structuralTestsSatisfiedByCodegen($ctx['codegenManifest'] ?? null);
+        if ($fromCodegen['satisfied']) {
+            return ['skip' => true, 'reason' => $fromCodegen['reason']];
+        }
+
+        $fromWorkspace = self::structuralTestsSatisfiedByWorkspace($ctx, (string) $ctx['repoRoot']);
+        if ($fromWorkspace['satisfied']) {
+            return ['skip' => true, 'reason' => $fromWorkspace['reason']];
+        }
+
+        return ['skip' => false, 'reason' => null];
+    }
+}

package/adapters/laravel/php/src/WriteFiles.php

@@ -0,0 +1,194 @@
+<?php
+
+declare(strict_types=1);
+
+namespace FlowGrid\Laravel\UnitGen;
+
+final class WriteFiles
+{
+    /**
+     * @param  list<array{relativePath: string, content: string, layer: string, patternId: string}>  $outputs
+     * @param  array{dryRun?: bool, force?: bool}  $options
+     * @return array{written: list<array<string, mixed>>, skipped: list<array<string, mixed>>}
+     */
+    public static function writeOutputs(string $repoRoot, array $outputs, array $options = []): array
+    {
+        $written = [];
+        $skipped = [];
+        $force = !empty($options['force']);
+        $dryRun = !empty($options['dryRun']);
+
+        foreach ($outputs as $output) {
+            $absolutePath = ProjectResolver::assertContained(
+                $repoRoot,
+                $repoRoot.DIRECTORY_SEPARATOR.str_replace('/', DIRECTORY_SEPARATOR, $output['relativePath']),
+                'unit output'
+            );
+
+            if (!$force && is_file($absolutePath)) {
+                $skipped[] = ['relativePath' => $output['relativePath'], 'reason' => 'exists (use --force)'];
+                continue;
+            }
+
+            if (!$dryRun) {
+                $dir = dirname($absolutePath);
+                if (!is_dir($dir)) {
+                    mkdir($dir, 0777, true);
+                }
+                file_put_contents($absolutePath, $output['content']);
+            }
+
+            $written[] = ['relativePath' => $output['relativePath'], 'dryRun' => $dryRun];
+        }
+
+        return ['written' => $written, 'skipped' => $skipped];
+    }
+
+    /**
+     * @param  array<string, mixed>  $manifest
+     * @param  array{dryRun?: bool}  $options
+     * @return array{manifestPath: string, handoffPath: string}
+     */
+    public static function writeUnitMeta(
+        string $featureDir,
+        array $manifest,
+        string $handoffMarkdown,
+        array $options = []
+    ): array {
+        $manifestPath = $featureDir.DIRECTORY_SEPARATOR.'generated'.DIRECTORY_SEPARATOR.'unit.manifest.json';
+        $handoffPath = $featureDir.DIRECTORY_SEPARATOR.'generated'.DIRECTORY_SEPARATOR.'UNIT-HANDOFF.md';
+
+        if (!empty($options['dryRun'])) {
+            return ['manifestPath' => $manifestPath, 'handoffPath' => $handoffPath];
+        }
+
+        $dir = dirname($manifestPath);
+        if (!is_dir($dir)) {
+            mkdir($dir, 0777, true);
+        }
+        file_put_contents(
+            $manifestPath,
+            json_encode($manifest, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES)."\n"
+        );
+        file_put_contents($handoffPath, $handoffMarkdown);
+
+        return ['manifestPath' => $manifestPath, 'handoffPath' => $handoffPath];
+    }
+
+    /**
+     * @param  array<string, mixed>  $ctx
+     * @param  list<array<string, mixed>>  $written
+     * @param  list<array<string, mixed>>  $skipped
+     * @param  list<array<string, mixed>>  $needsUnit
+     * @param  list<array<string, mixed>>  $commands
+     * @param  list<array<string, mixed>>  $skippedPatterns
+     */
+    public static function renderUnitHandoffMarkdown(
+        array $ctx,
+        array $written,
+        array $skipped,
+        array $needsUnit,
+        array $commands,
+        array $skippedPatterns = []
+    ): string {
+        $testPaths = array_map(static fn ($w) => $w['relativePath'], $written);
+        $filterHint = $ctx['entity'];
+        $lines = [
+            '# UNIT HANDOFF — '.$ctx['title'],
+            '',
+            'Generated from `'.basename((string) $ctx['specFile']).'` (profile: **'.$ctx['profile'].'**, phase: **'.$ctx['phase'].'**).',
+            '',
+            'Prerequisite: `flowgrid api-gen` + `generated/codegen.manifest.json`.',
+            '',
+            '## Commands (stub layer)',
+            '',
+        ];
+
+        if ($commands !== []) {
+            foreach ($commands as $c) {
+                $lines[] = '- `php artisan '.$c['artisan'].'`';
+            }
+        } else {
+            $lines[] = '- _No artisan commands planned._';
+        }
+        $lines[] = '';
+
+        if ($skippedPatterns !== []) {
+            $lines[] = '## Skipped patterns';
+            $lines[] = '';
+            foreach ($skippedPatterns as $item) {
+                $extra = !empty($item['artisan']) ? ' (`'.$item['artisan'].'`)' : '';
+                $lines[] = '- `'.$item['patternId'].'` — '.$item['reason'].$extra;
+            }
+            $lines[] = '';
+        }
+
+        $lines[] = '## Test files';
+        $lines[] = '';
+        if ($written !== []) {
+            foreach ($written as $f) {
+                $dry = !empty($f['dryRun']) ? ' (dry-run)' : '';
+                $lines[] = '- `'.$f['relativePath'].'`'.$dry;
+            }
+        } else {
+            $lines[] = '- _No template files written._';
+        }
+        $lines[] = '';
+
+        if ($skipped !== []) {
+            $lines[] = '## Skipped (already exist)';
+            $lines[] = '';
+            foreach ($skipped as $s) {
+                $lines[] = '- `'.$s['relativePath'].'` — '.$s['reason'];
+            }
+            $lines[] = '';
+        }
+
+        $lines[] = '## Verify';
+        $lines[] = '';
+        $lines[] = '```bash';
+        $lines[] = 'php artisan test --testsuite=Module'.$ctx['module'];
+        $lines[] = $testPaths !== []
+            ? 'php artisan test '.implode(' ', $testPaths)
+            : 'php artisan test --filter='.$filterHint;
+        $lines[] = '```';
+        $lines[] = '';
+
+        if ($needsUnit !== []) {
+            $lines[] = '## Unit next — #needs-unit-test';
+            $lines[] = '';
+            foreach ($needsUnit as $item) {
+                $lines[] = '- `'.$item['tag'].'` — '.$item['reason'];
+            }
+            $lines[] = '';
+        }
+
+        return implode("\n", $lines);
+    }
+
+    /**
+     * @param  list<array<string, mixed>>  $files
+     * @param  array<string, mixed>  $ctx
+     * @return list<array{relativePath: string, content: string, layer: string, patternId: string}>
+     */
+    public static function renderFileOutputs(array $files, array $ctx): array
+    {
+        $outputs = [];
+        foreach ($files as $file) {
+            $context = array_merge($ctx, $file['context'] ?? [], [
+                'moduleNamespace' => $ctx['moduleNamespace'],
+                'moduleBaseRequestFqcn' => $ctx['moduleBaseRequestFqcn'],
+                'moduleBaseRequestClass' => $ctx['moduleBaseRequestClass'],
+                'moduleControllerFqcn' => $ctx['moduleControllerFqcn'],
+            ]);
+            $outputs[] = [
+                'relativePath' => $file['relativePath'],
+                'content' => TemplateRenderer::render((string) $file['template'], $context),
+                'layer' => (string) $file['layer'],
+                'patternId' => (string) $file['patternId'],
+            ];
+        }
+
+        return $outputs;
+    }
+}

package/adapters/laravel/php/templates/actions/relationship-sync.behavior.test.php.stub

@@ -0,0 +1,50 @@
+<?php
+
+
+
+namespace {{moduleNamespace}}\Tests\Unit\Http\Actions;
+
+
+
+use {{phpFqcn entityActionFqcn}};
+
+use {{phpFqcn modelFqcn}};
+
+use Tests\Unit\Concerns\AssertsActionRelationshipKeys;
+
+use Tests\Unit\UnitTestCase;
+
+
+
+class {{entity}}ActionRelationshipsBehaviorTest extends UnitTestCase
+
+{
+
+    use AssertsActionRelationshipKeys;
+
+
+
+    public function test_model_defines_spec_relationships(): void
+
+    {
+
+        $this->assertModelDefinesRelationships({{phpFqcn modelFqcn}}::class, {{phpStringArray relationshipNames}});
+
+    }
+
+
+
+    public function test_action_uses_entity_model(): void
+
+    {
+
+        $action = new {{phpFqcn entityActionFqcn}}(new {{phpFqcn modelFqcn}}());
+
+
+
+        $this->assertInstanceOf({{phpFqcn entityActionFqcn}}::class, $action);
+
+    }
+
+}
+

package/adapters/laravel/php/templates/controllers/controller-invoke.test.php.stub

@@ -0,0 +1,34 @@
+<?php
+
+namespace {{moduleNamespace}}\Tests\Feature\Http\Controllers;
+
+use {{phpFqcn controllerFqcn}};
+use {{phpFqcn entityActionFqcn}};
+use {{phpFqcn entityQueryFqcn}};
+use {{moduleNamespace}}\Tests\Support\ModuleTestSupport;
+use Tests\Unit\UnitTestCase;
+
+class {{entity}}ControllerInvokeTest extends UnitTestCase
+{
+    use ModuleTestSupport;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->app->bind(
+            {{phpFqcn entityQueryFqcn}}::class,
+            fn () => $this->makeQueryDouble({{phpFqcn entityQueryFqcn}}::class),
+        );
+        $this->app->bind(
+            {{phpFqcn entityActionFqcn}}::class,
+            fn () => $this->makeActionDouble({{phpFqcn entityActionFqcn}}::class),
+        );
+    }
+
+    public function test_public_methods_are_invokable(): void
+    {
+        $controller = $this->app->make({{phpFqcn controllerFqcn}}::class);
+        $this->invokeAllControllerMethods($controller);
+    }
+}

package/adapters/laravel/php/templates/queries/chain-scope.behavior.test.php.stub

@@ -0,0 +1,34 @@
+<?php
+
+namespace {{moduleNamespace}}\Tests\Unit\Http\Queries;
+
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Database\Eloquent\Model;
+use Tests\Unit\Concerns\AssertsQuerySessionScope;
+use Tests\Unit\UnitTestCase;
+
+class {{entity}}QueryChainScopeBehaviorTest extends UnitTestCase
+{
+    use AssertsQuerySessionScope;
+
+    public function test_query_can_apply_session_scope_column(): void
+    {
+        $column = '{{sessionScopeColumn}}';
+
+        $builder = $this->makeScopedBuilder($column);
+
+        $this->assertNotEmpty($builder->getQuery()->wheres);
+        $this->assertQueryBuilderAppliesScope($builder, $column);
+    }
+
+    private function makeScopedBuilder(string $column): Builder
+    {
+        $model = new class extends Model {
+            protected $table = 'unit_test_scope';
+
+            public $timestamps = false;
+        };
+
+        return $model->newQuery()->where($column, 1);
+    }
+}

package/adapters/laravel/php/templates/requests/default-per-page.behavior.test.php.stub

@@ -0,0 +1,19 @@
+<?php
+
+namespace {{moduleNamespace}}\Tests\Unit\Http\Requests;
+
+use {{phpFqcn searchRequestFqcn}};
+use Tests\Unit\Concerns\AssertsSearchRequestPagination;
+use Tests\Unit\UnitTestCase;
+
+class {{entity}}SearchRequestDefaultPerPageBehaviorTest extends UnitTestCase
+{
+    use AssertsSearchRequestPagination;
+
+    public function test_search_request_default_max_per_page_matches_spec(): void
+    {
+        $request = new {{phpFqcn searchRequestFqcn}}();
+
+        $this->assertSearchRequestMaxPerPage($request, {{perPageDefault}});
+    }
+}

package/adapters/laravel/php/templates/requests/request-enriched.test.php.stub

@@ -0,0 +1,66 @@
+<?php
+
+namespace {{moduleNamespace}}\Tests\Unit\Http\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+use ReflectionClass;
+use {{phpFqcn requestFqcn}};
+use {{moduleNamespace}}\Tests\Support\ModuleTestSupport;
+use Tests\Unit\UnitTestCase;
+
+class {{requestClass}}Test extends UnitTestCase
+{
+    use ModuleTestSupport;
+
+    public function test_target_file_exists(): void
+    {
+        $this->assertFileExists(base_path('{{targetRelativePath}}'));
+    }
+
+    public function test_target_class_declaration_matches_expected_fqcn(): void
+    {
+        $path = base_path('{{targetRelativePath}}');
+        $contents = file_get_contents($path);
+
+        $this->assertNotFalse($contents, "Unable to read [{$path}].");
+
+        preg_match('/^namespace\s+([^;]+);/m', $contents, $namespaceMatches);
+        preg_match('/^\s*(?:abstract\s+|final\s+)?(?:class|interface|trait|enum)\s+([A-Za-z_][A-Za-z0-9_]*)/m', $contents, $classMatches);
+
+        $this->assertArrayHasKey(1, $namespaceMatches, "No namespace declaration found in [{$path}].");
+        $this->assertArrayHasKey(1, $classMatches, "No class-like declaration found in [{$path}].");
+
+        $declaredFqcn = trim($namespaceMatches[1]).'\\'.trim($classMatches[1]);
+        $this->assertSame('{{requestFqcn}}', $declaredFqcn);
+    }
+
+    public function test_request_class_is_loadable(): void
+    {
+        $this->assertTrue(class_exists({{phpFqcn requestFqcn}}::class));
+    }
+
+    public function test_request_extends_form_request(): void
+    {
+        $this->assertTrue(is_subclass_of({{phpFqcn requestFqcn}}::class, FormRequest::class));
+    }
+
+    public function test_request_can_be_instantiated(): void
+    {
+        $reflection = new ReflectionClass({{phpFqcn requestFqcn}}::class);
+
+        if ($reflection->isAbstract()) {
+            $request = new class extends {{phpFqcn requestFqcn}} {};
+        } else {
+            $request = new {{phpFqcn requestFqcn}}();
+        }
+
+        $this->assertTrue($request->authorize());
+        $this->assertIsArray($request->rules());
+    }
+
+    public function test_validation_hooks(): void
+    {
+        $request = $this->makeSearchRequestInstance({{phpFqcn requestFqcn}}::class);
+        $this->exerciseRequestValidationHooks($request);
+    }
+}

package/adapters/laravel/php/templates/requests/rules-keys.behavior.test.php.stub

@@ -0,0 +1,19 @@
+<?php
+
+namespace {{moduleNamespace}}\Tests\Unit\Http\Requests;
+
+use {{phpFqcn searchRequestFqcn}};
+use Tests\Unit\Concerns\AssertsRequestRuleKeys;
+use Tests\Unit\UnitTestCase;
+
+class {{entity}}SearchRequestRulesKeysBehaviorTest extends UnitTestCase
+{
+    use AssertsRequestRuleKeys;
+
+    public function test_search_request_rules_contain_spec_keys(): void
+    {
+        $request = new {{phpFqcn searchRequestFqcn}}();
+
+        $this->assertRequestRulesContainKeys($request, {{phpStringArray ruleKeys}});
+    }
+}

package/adapters/laravel/php/templates/resources/nested-relations.behavior.test.php.stub

@@ -0,0 +1,25 @@
+<?php
+
+namespace {{moduleNamespace}}\Tests\Unit\Http\Resources;
+
+use Illuminate\Http\Request;
+use {{phpFqcn entityResourceFqcn}};
+use {{phpFqcn modelFqcn}};
+use Tests\Unit\UnitTestCase;
+
+class {{entity}}ResourceNestedRelationsBehaviorTest extends UnitTestCase
+{
+    public function test_resource_exposes_nested_relation_when_loaded(): void
+    {
+        $model = new {{phpFqcn modelFqcn}}();
+        $model->forceFill(['id' => 1, 'name' => 'Spec Hotel']);
+
+        $nested = (object) ['id' => 10, 'full_name' => 'Manager A'];
+        $model->setRelation('{{nestedRelationKey}}', collect([$nested]));
+
+        $data = (new {{phpFqcn entityResourceFqcn}}($model))->toArray(Request::create('/admin-test', 'GET'));
+
+        $this->assertArrayHasKey('{{nestedRelationKey}}', $data);
+        $this->assertIsArray($data['{{nestedRelationKey}}']);
+    }
+}