From a2f46b9f7d27f5972fbb60aca2f409bb86d4692d Mon Sep 17 00:00:00 2001 From: Guajiro <276488307+Guajir0-code@users.noreply.github.com> Date: Wed, 5 Aug 2026 10:10:55 -0300 Subject: [PATCH] test: add WordPress fixtures and route coverage The app points Eloquent at an existing WordPress database, so no migration creates wp_posts, wp_users, wp_terms and friends. Any test that touched the database therefore could not run, and the single feature test in the repo (GET / asserting 200) failed on a missing database. Add a schema builder for the wp_* tables the app reads, small row builders, and smoke coverage for all seven routes in routes/web.php, including the highlighted-post exclusion, search, and the published/scheduled filtering the global scope is responsible for. withoutVite() keeps the suite independent of `npm run build`. ExampleTest is dropped: RoutesTest covers GET / properly. Co-Authored-By: Claude Opus 5 --- phpunit.xml | 3 +- tests/Feature/ExampleTest.php | 7 -- tests/Feature/RoutesTest.php | 139 ++++++++++++++++++++++++++++++ tests/Pest.php | 11 +++ tests/Support/WordPressSchema.php | 104 ++++++++++++++++++++++ tests/Support/Wp.php | 130 ++++++++++++++++++++++++++++ 6 files changed, 386 insertions(+), 8 deletions(-) delete mode 100644 tests/Feature/ExampleTest.php create mode 100644 tests/Feature/RoutesTest.php create mode 100644 tests/Support/WordPressSchema.php create mode 100644 tests/Support/Wp.php diff --git a/phpunit.xml b/phpunit.xml index c09b5bc..61c031c 100644 --- a/phpunit.xml +++ b/phpunit.xml @@ -22,7 +22,8 @@ - + + diff --git a/tests/Feature/ExampleTest.php b/tests/Feature/ExampleTest.php deleted file mode 100644 index 1e2a000..0000000 --- a/tests/Feature/ExampleTest.php +++ /dev/null @@ -1,7 +0,0 @@ -get('/'); - - $response->assertStatus(200); -}); diff --git a/tests/Feature/RoutesTest.php b/tests/Feature/RoutesTest.php new file mode 100644 index 0000000..8ebf750 --- /dev/null +++ b/tests/Feature/RoutesTest.php @@ -0,0 +1,139 @@ +author = Wp::user([ + 'user_login' => 'mayron', + 'user_nicename' => 'mayron', + 'display_name' => 'Autor Um', + 'user_email' => 'autor@example.com', + ]); + + $this->post = Wp::post([ + 'post_author' => $this->author->ID, + 'post_title' => 'Primeiro post', + 'post_name' => 'primeiro-post', + 'post_date' => '2026-07-15 12:00:00', + ]); + + Wp::categorise($this->post->ID, 'games'); + Wp::categorise($this->post->ID, 'lancamentos', 'post_tag'); + Wp::thumbnail($this->post->ID); +}); + +it('renders the home page', function () { + $this->get('/') + ->assertOk() + ->assertInertia(fn ($page) => $page + ->component('Home') + ->has('posts.data', 1) + ->where('posts.data.0.title', 'Primeiro post') + ); +}); + +it('excludes highlighted posts from the home listing', function () { + $highlighted = Wp::post(['post_title' => 'Em destaque', 'post_name' => 'em-destaque']); + Wp::categorise($highlighted->ID, 'destaques'); + + $this->get('/') + ->assertOk() + ->assertInertia(fn ($page) => $page + ->has('posts.data', 1) + ->has('highlightedPosts.data', 1) + ->where('posts.data.0.title', 'Primeiro post') + ->where('highlightedPosts.data.0.title', 'Em destaque') + ); +}); + +it('renders a single post', function () { + $this->get('/2026/07/primeiro-post') + ->assertOk() + ->assertInertia(fn ($page) => $page + ->component('PostContent') + ->where('post.data.title', 'Primeiro post') + ->where('post.data.slug', 'primeiro-post') + ); +}); + +it('returns 404 for an unknown post slug', function () { + $this->get('/2026/07/nao-existe')->assertNotFound(); +}); + +it('renders the category listing', function () { + $this->get('/category/games') + ->assertOk() + ->assertInertia(fn ($page) => $page + ->component('CategoryPosts') + ->has('posts.data', 1) + ); +}); + +it('renders the tag listing', function () { + $this->get('/tag/lancamentos') + ->assertOk() + ->assertInertia(fn ($page) => $page + ->component('TagPosts') + ->has('posts.data', 1) + ); +}); + +it('renders the author listing', function () { + $this->get('/author/mayron') + ->assertOk() + ->assertInertia(fn ($page) => $page + ->component('AuthorPosts') + ->has('posts.data', 1) + ); +}); + +it('renders the year and month archive', function () { + $this->get('/2026/07') + ->assertOk() + ->assertInertia(fn ($page) => $page + ->component('YearMonthPosts') + ->has('posts.data', 1) + ); +}); + +it('renders the privacy policy page', function () { + Wp::post([ + 'post_title' => 'Politica de Privacidade', + 'post_name' => 'politica-de-privacidade', + 'post_type' => 'page', + ]); + + $this->get('/politica-de-privacidade') + ->assertOk() + ->assertInertia(fn ($page) => $page + ->component('PrivacyPolicy') + ->where('page.data.title', 'Politica de Privacidade') + ); +}); + +it('finds posts by search term', function () { + Wp::post(['post_title' => 'Outro assunto', 'post_name' => 'outro-assunto']); + + $this->get('/?s=Primeiro') + ->assertOk() + ->assertInertia(fn ($page) => $page + ->where('searchTerm', 'Primeiro') + ->has('posts.data', 1) + ->where('posts.data.0.title', 'Primeiro post') + ); +}); + +it('hides posts that are not published', function () { + Wp::post(['post_title' => 'Rascunho', 'post_name' => 'rascunho', 'post_status' => 'draft']); + Wp::post(['post_title' => 'Futuro', 'post_name' => 'futuro', 'post_date' => '2099-01-01 00:00:00']); + + $this->get('/') + ->assertOk() + ->assertInertia(fn ($page) => $page->has('posts.data', 1)); +}); diff --git a/tests/Pest.php b/tests/Pest.php index 40d096b..3c76ee0 100644 --- a/tests/Pest.php +++ b/tests/Pest.php @@ -13,6 +13,17 @@ pest()->extend(Tests\TestCase::class) ->use(Illuminate\Foundation\Testing\RefreshDatabase::class) + ->beforeEach(function () { + // The app reads an existing WordPress database, so there are no + // migrations for wp_* tables. Build them per test instead. + Tests\Support\WordPressSchema::create(); + + // Rendering the root Blade view resolves @vite, which needs a built + // manifest. Stub it so the suite does not depend on `npm run build`. + $this->withoutVite(); + + cache()->flush(); + }) ->in('Feature'); /* diff --git a/tests/Support/WordPressSchema.php b/tests/Support/WordPressSchema.php new file mode 100644 index 0000000..df23af6 --- /dev/null +++ b/tests/Support/WordPressSchema.php @@ -0,0 +1,104 @@ + Drop order matters only for readability; sqlite has no FKs here. + */ + private const TABLES = [ + 'wp_posts', + 'wp_postmeta', + 'wp_users', + 'wp_usermeta', + 'wp_terms', + 'wp_term_taxonomy', + 'wp_term_relationships', + ]; + + public static function create(): void + { + self::drop(); + + Schema::create('wp_posts', function (Blueprint $table) { + $table->id('ID'); + $table->unsignedBigInteger('post_author')->default(0); + $table->dateTime('post_date')->nullable(); + $table->longText('post_content')->nullable(); + $table->text('post_title')->nullable(); + $table->text('post_excerpt')->nullable(); + $table->string('post_status', 20)->default('publish'); + $table->string('post_name', 200)->default(''); + $table->string('post_type', 20)->default('post'); + $table->string('guid', 255)->default(''); + $table->integer('menu_order')->default(0); + $table->unsignedBigInteger('post_parent')->default(0); + }); + + Schema::create('wp_postmeta', function (Blueprint $table) { + $table->id('meta_id'); + $table->unsignedBigInteger('post_id')->default(0); + $table->string('meta_key', 255)->nullable(); + $table->longText('meta_value')->nullable(); + }); + + Schema::create('wp_users', function (Blueprint $table) { + $table->id('ID'); + $table->string('user_login', 60)->default(''); + $table->string('user_pass', 255)->default(''); + $table->string('user_nicename', 50)->default(''); + $table->string('user_email', 100)->default(''); + $table->string('display_name', 250)->default(''); + }); + + Schema::create('wp_usermeta', function (Blueprint $table) { + $table->id('umeta_id'); + $table->unsignedBigInteger('user_id')->default(0); + $table->string('meta_key', 255)->nullable(); + $table->longText('meta_value')->nullable(); + }); + + Schema::create('wp_terms', function (Blueprint $table) { + $table->id('term_id'); + $table->string('name', 200)->default(''); + $table->string('slug', 200)->default(''); + }); + + Schema::create('wp_term_taxonomy', function (Blueprint $table) { + $table->id('term_taxonomy_id'); + $table->unsignedBigInteger('term_id')->default(0); + $table->string('taxonomy', 32)->default(''); + $table->longText('description')->nullable(); + $table->unsignedBigInteger('parent')->default(0); + $table->bigInteger('count')->default(0); + }); + + Schema::create('wp_term_relationships', function (Blueprint $table) { + $table->unsignedBigInteger('object_id')->default(0); + $table->unsignedBigInteger('term_taxonomy_id')->default(0); + $table->integer('term_order')->default(0); + }); + } + + public static function drop(): void + { + foreach (self::TABLES as $table) { + Schema::dropIfExists($table); + } + } +} diff --git a/tests/Support/Wp.php b/tests/Support/Wp.php new file mode 100644 index 0000000..9c29ebf --- /dev/null +++ b/tests/Support/Wp.php @@ -0,0 +1,130 @@ +insertGetId(array_merge([ + 'user_login' => 'autor', + 'user_pass' => '$P$Bexamplehashexamplehashexample', + 'user_nicename' => 'autor', + 'user_email' => 'autor@example.com', + 'display_name' => 'Autor de Teste', + ], $attributes), 'ID'); + + return WpUser::query()->findOrFail($id); + } + + public static function post(array $attributes = []): WpPost + { + $id = DB::table('wp_posts')->insertGetId(array_merge([ + 'post_author' => 1, + 'post_date' => '2026-07-15 12:00:00', + 'post_title' => 'Post de teste', + 'post_excerpt' => 'Resumo do post.', + 'post_content' => 'Conteudo do post.', + 'post_name' => 'post-de-teste', + 'post_status' => 'publish', + 'post_type' => 'post', + ], $attributes), 'ID'); + + return WpPost::withoutGlobalScopes()->findOrFail($id); + } + + /** + * Creates a term in the given taxonomy and returns its term_taxonomy_id. + */ + public static function term(string $slug, string $taxonomy = 'category', ?string $name = null): int + { + $termId = DB::table('wp_terms')->insertGetId([ + 'name' => $name ?? ucfirst($slug), + 'slug' => $slug, + ], 'term_id'); + + return DB::table('wp_term_taxonomy')->insertGetId([ + 'term_id' => $termId, + 'taxonomy' => $taxonomy, + ], 'term_taxonomy_id'); + } + + public static function attach(int $postId, int $termTaxonomyId): void + { + DB::table('wp_term_relationships')->insert([ + 'object_id' => $postId, + 'term_taxonomy_id' => $termTaxonomyId, + ]); + } + + /** + * Convenience: create the term if needed and attach it in one call. + */ + public static function categorise(int $postId, string $slug, string $taxonomy = 'category'): int + { + $ttId = DB::table('wp_term_taxonomy') + ->join('wp_terms', 'wp_terms.term_id', '=', 'wp_term_taxonomy.term_id') + ->where('wp_terms.slug', $slug) + ->where('wp_term_taxonomy.taxonomy', $taxonomy) + ->value('wp_term_taxonomy.term_taxonomy_id'); + + $ttId ??= self::term($slug, $taxonomy); + + self::attach($postId, $ttId); + + return $ttId; + } + + /** + * Attaches a featured image: an attachment post plus the _thumbnail_id meta + * that WpPost::getThumbnail() resolves. + */ + public static function thumbnail(int $postId, string $url = 'https://example.com/capa.jpg'): int + { + $attachmentId = DB::table('wp_posts')->insertGetId([ + 'post_title' => 'capa', + 'post_name' => 'capa', + 'post_type' => 'attachment', + 'post_status' => 'inherit', + 'post_date' => '2026-07-15 12:00:00', + 'guid' => $url, + ], 'ID'); + + DB::table('wp_postmeta')->insert([ + 'post_id' => $postId, + 'meta_key' => '_thumbnail_id', + 'meta_value' => (string) $attachmentId, + ]); + + return $attachmentId; + } + + public static function postMeta(int $postId, string $key, string $value): void + { + DB::table('wp_postmeta')->insert([ + 'post_id' => $postId, + 'meta_key' => $key, + 'meta_value' => $value, + ]); + } + + public static function userMeta(int $userId, string $key, string $value): void + { + DB::table('wp_usermeta')->insert([ + 'user_id' => $userId, + 'meta_key' => $key, + 'meta_value' => $value, + ]); + } +}