feat: increase gallery grid from 4 to 5 columns per row on desktopfeat: increase gallery grid from 4 to 5 columns per row on desktop

2026-02-25 19:11:23 +01:00
parent 5c97488e80
commit 0032aec02f
131 changed files with 15674 additions and 597 deletions
--- a/tests/Feature/ArtworkAwardTest.php
+++ b/tests/Feature/ArtworkAwardTest.php
@@ -0,0 +1,292 @@
+<?php
+
+declare(strict_types=1);
+
+use App\Models\Artwork;
+use App\Models\ArtworkAward;
+use App\Models\ArtworkAwardStat;
+use App\Models\User;
+use App\Services\ArtworkAwardService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+
+uses(RefreshDatabase::class);
+
+// ---------------------------------------------------------------------------
+// Helper
+// ---------------------------------------------------------------------------
+
+function makePublishedArtwork(array $attrs = []): Artwork
+{
+    return Artwork::factory()->create(array_merge([
+        'is_public'   => true,
+        'is_approved' => true,
+    ], $attrs));
+}
+
+// ---------------------------------------------------------------------------
+// Service-layer tests
+// ---------------------------------------------------------------------------
+
+test('user can award an artwork', function () {
+    $service = app(ArtworkAwardService::class);
+    $user    = User::factory()->create(['created_at' => now()->subDays(30)]);
+    $artwork = makePublishedArtwork(['user_id' => User::factory()->create()->id]);
+
+    $award = $service->award($artwork, $user, 'gold');
+
+    expect($award->medal)->toBe('gold')
+        ->and($award->weight)->toBe(3)
+        ->and($award->artwork_id)->toBe($artwork->id)
+        ->and($award->user_id)->toBe($user->id);
+});
+
+test('stats are recalculated after awarding', function () {
+    $service = app(ArtworkAwardService::class);
+    $owner   = User::factory()->create();
+    $artwork = makePublishedArtwork(['user_id' => $owner->id]);
+
+    $userA = User::factory()->create();
+    $userB = User::factory()->create();
+    $userC = User::factory()->create();
+
+    $service->award($artwork, $userA, 'gold');
+    $service->award($artwork, $userB, 'silver');
+    $service->award($artwork, $userC, 'bronze');
+
+    $stat = ArtworkAwardStat::find($artwork->id);
+
+    expect($stat->gold_count)->toBe(1)
+        ->and($stat->silver_count)->toBe(1)
+        ->and($stat->bronze_count)->toBe(1)
+        ->and($stat->score_total)->toBe(6); // 3+2+1
+});
+
+test('duplicate award is rejected', function () {
+    $service = app(ArtworkAwardService::class);
+    $user    = User::factory()->create();
+    $artwork = makePublishedArtwork(['user_id' => User::factory()->create()->id]);
+
+    $service->award($artwork, $user, 'gold');
+
+    expect(fn () => $service->award($artwork, $user, 'silver'))
+        ->toThrow(Illuminate\Validation\ValidationException::class);
+});
+
+test('user can change their award', function () {
+    $service = app(ArtworkAwardService::class);
+    $user    = User::factory()->create();
+    $artwork = makePublishedArtwork(['user_id' => User::factory()->create()->id]);
+
+    $service->award($artwork, $user, 'gold');
+    $updated = $service->changeAward($artwork, $user, 'bronze');
+
+    expect($updated->medal)->toBe('bronze')
+        ->and($updated->weight)->toBe(1);
+
+    $stat = ArtworkAwardStat::find($artwork->id);
+    expect($stat->gold_count)->toBe(0)
+        ->and($stat->bronze_count)->toBe(1)
+        ->and($stat->score_total)->toBe(1);
+});
+
+test('user can remove their award', function () {
+    $service = app(ArtworkAwardService::class);
+    $user    = User::factory()->create();
+    $artwork = makePublishedArtwork(['user_id' => User::factory()->create()->id]);
+
+    $service->award($artwork, $user, 'silver');
+    $service->removeAward($artwork, $user);
+
+    expect(ArtworkAward::where('artwork_id', $artwork->id)->where('user_id', $user->id)->exists())
+        ->toBeFalse();
+
+    $stat = ArtworkAwardStat::find($artwork->id);
+    expect($stat)->not->toBeNull()
+        ->and($stat->silver_count)->toBe(0)
+        ->and($stat->score_total)->toBe(0);
+});
+
+test('score formula is gold×3 + silver×2 + bronze×1', function () {
+    $service = app(ArtworkAwardService::class);
+    $owner   = User::factory()->create();
+    $artwork = makePublishedArtwork(['user_id' => $owner->id]);
+
+    foreach (['gold', 'gold', 'silver', 'bronze'] as $medal) {
+        $service->award($artwork, User::factory()->create(), $medal);
+    }
+
+    $stat = ArtworkAwardStat::find($artwork->id);
+    expect($stat->score_total)->toBe((2 * 3) + (1 * 2) + (1 * 1)); // 9
+});
+
+// ---------------------------------------------------------------------------
+// API endpoint tests
+// ---------------------------------------------------------------------------
+
+test('POST /api/artworks/{id}/award — guest is rejected', function () {
+    $artwork = makePublishedArtwork(['user_id' => User::factory()->create()->id]);
+
+    $this->postJson("/api/artworks/{$artwork->id}/award", ['medal' => 'gold'])
+        ->assertUnauthorized();
+});
+
+test('POST /api/artworks/{id}/award — authenticated user can award', function () {
+    $user    = User::factory()->create(['created_at' => now()->subDays(30)]);
+    $artwork = makePublishedArtwork(['user_id' => User::factory()->create()->id]);
+
+    $this->actingAs($user)
+        ->postJson("/api/artworks/{$artwork->id}/award", ['medal' => 'gold'])
+        ->assertCreated()
+        ->assertJsonPath('awards.gold', 1)
+        ->assertJsonPath('viewer_award', 'gold');
+});
+
+test('POST /api/artworks/{id}/award — duplicate is rejected with 422', function () {
+    $user    = User::factory()->create(['created_at' => now()->subDays(30)]);
+    $artwork = makePublishedArtwork(['user_id' => User::factory()->create()->id]);
+
+    ArtworkAward::create([
+        'artwork_id' => $artwork->id,
+        'user_id'    => $user->id,
+        'medal'      => 'gold',
+        'weight'     => 3,
+    ]);
+
+    $this->actingAs($user)
+        ->postJson("/api/artworks/{$artwork->id}/award", ['medal' => 'silver'])
+        ->assertUnprocessable();
+});
+
+test('PUT /api/artworks/{id}/award — user can change their award', function () {
+    $user    = User::factory()->create(['created_at' => now()->subDays(30)]);
+    $artwork = makePublishedArtwork(['user_id' => User::factory()->create()->id]);
+
+    ArtworkAward::create([
+        'artwork_id' => $artwork->id,
+        'user_id'    => $user->id,
+        'medal'      => 'gold',
+        'weight'     => 3,
+    ]);
+
+    $this->actingAs($user)
+        ->putJson("/api/artworks/{$artwork->id}/award", ['medal' => 'bronze'])
+        ->assertOk()
+        ->assertJsonPath('viewer_award', 'bronze');
+});
+
+test('DELETE /api/artworks/{id}/award — user can remove their award', function () {
+    $user    = User::factory()->create(['created_at' => now()->subDays(30)]);
+    $artwork = makePublishedArtwork(['user_id' => User::factory()->create()->id]);
+
+    ArtworkAward::create([
+        'artwork_id' => $artwork->id,
+        'user_id'    => $user->id,
+        'medal'      => 'silver',
+        'weight'     => 2,
+    ]);
+
+    $this->actingAs($user)
+        ->deleteJson("/api/artworks/{$artwork->id}/award")
+        ->assertOk()
+        ->assertJsonPath('viewer_award', null);
+
+    expect(ArtworkAward::where('artwork_id', $artwork->id)->exists())->toBeFalse();
+});
+
+test('GET /api/artworks/{id}/awards — returns stats publicly', function () {
+    $owner   = User::factory()->create();
+    $artwork = makePublishedArtwork(['user_id' => $owner->id]);
+
+    ArtworkAwardStat::create([
+        'artwork_id'   => $artwork->id,
+        'gold_count'   => 2,
+        'silver_count' => 1,
+        'bronze_count' => 3,
+        'score_total'  => 11,
+        'updated_at'   => now(),
+    ]);
+
+    $this->getJson("/api/artworks/{$artwork->id}/awards")
+        ->assertOk()
+        ->assertJsonPath('awards.gold', 2)
+        ->assertJsonPath('awards.silver', 1)
+        ->assertJsonPath('awards.bronze', 3)
+        ->assertJsonPath('awards.score', 11);
+});
+
+test('observer recalculates stats when award is created', function () {
+    $user    = User::factory()->create();
+    $artwork = makePublishedArtwork(['user_id' => User::factory()->create()->id]);
+
+    ArtworkAward::create([
+        'artwork_id' => $artwork->id,
+        'user_id'    => $user->id,
+        'medal'      => 'gold',
+        'weight'     => 3,
+    ]);
+
+    $stat = ArtworkAwardStat::find($artwork->id);
+    expect($stat->gold_count)->toBe(1)
+        ->and($stat->score_total)->toBe(3);
+});
+
+// ---------------------------------------------------------------------------
+// Abuse / security tests
+// ---------------------------------------------------------------------------
+
+test('new account (< 7 days) is rejected with 403', function () {
+    $user    = User::factory()->create(['created_at' => now()->subHours(12)]);
+    $artwork = makePublishedArtwork(['user_id' => User::factory()->create()->id]);
+
+    $this->actingAs($user)
+        ->postJson("/api/artworks/{$artwork->id}/award", ['medal' => 'gold'])
+        ->assertForbidden();
+});
+
+test('user cannot award their own artwork', function () {
+    $user    = User::factory()->create(['created_at' => now()->subDays(30)]);
+    $artwork = makePublishedArtwork(['user_id' => $user->id]);
+
+    $this->actingAs($user)
+        ->postJson("/api/artworks/{$artwork->id}/award", ['medal' => 'gold'])
+        ->assertForbidden();
+});
+
+// ---------------------------------------------------------------------------
+// Meilisearch sync test
+// ---------------------------------------------------------------------------
+
+test('syncToSearch is called when an award is given', function () {
+    $service = $this->partialMock(
+        \App\Services\ArtworkAwardService::class,
+        function (\Mockery\MockInterface $mock) {
+            $mock->shouldReceive('syncToSearch')->atLeast()->once();
+        }
+    );
+
+    $user    = User::factory()->create();
+    $artwork = makePublishedArtwork(['user_id' => User::factory()->create()->id]);
+
+    $service->award($artwork, $user, 'silver');
+});
+
+test('syncToSearch is called when an award is removed', function () {
+    $service = $this->partialMock(
+        \App\Services\ArtworkAwardService::class,
+        function (\Mockery\MockInterface $mock) {
+            $mock->shouldReceive('syncToSearch')->atLeast()->once();
+        }
+    );
+
+    $user    = User::factory()->create();
+    $artwork = makePublishedArtwork(['user_id' => User::factory()->create()->id]);
+
+    ArtworkAward::create([
+        'artwork_id' => $artwork->id,
+        'user_id'    => $user->id,
+        'medal'      => 'gold',
+        'weight'     => 3,
+    ]);
+
+    $service->removeAward($artwork, $user);
+});
--- a/tests/Feature/TagPageTest.php
+++ b/tests/Feature/TagPageTest.php
@@ -0,0 +1,63 @@
+<?php
+
+declare(strict_types=1);
+
+use App\Models\Tag;
+
+it('renders the tag page with correct title and canonical', function (): void {
+    $tag = Tag::factory()->create(['name' => 'Cyberpunk', 'slug' => 'cyberpunk', 'is_active' => true]);
+
+    $response = $this->get('/tag/cyberpunk');
+
+    $response->assertOk();
+    $html = $response->getContent();
+    expect($html)
+        ->toContain('Cyberpunk')
+        ->toContain('index,follow');
+});
+
+it('returns 404 for a non-existent tag slug', function (): void {
+    $this->get('/tag/does-not-exist-xyz')->assertNotFound();
+});
+
+it('renders tag page with artworks from the tag', function (): void {
+    // The tag page uses Meilisearch (SCOUT_DRIVER=null in tests → empty results).
+    // We verify the page renders correctly with tag metadata; artwork grid
+    // content is covered by browser/e2e tests against a live index.
+    $tag = Tag::factory()->create(['name' => 'Night', 'slug' => 'night', 'is_active' => true]);
+
+    $response = $this->get('/tag/night');
+
+    $response->assertOk();
+    expect($response->getContent())
+        ->toContain('Night')
+        ->toContain('index,follow');
+});
+
+it('shows pagination rel links on tag pages with enough artworks', function (): void {
+    // NOTE: pagination rel links are injected only when the Meilisearch paginator
+    // returns > per_page results. SCOUT_DRIVER=null returns an empty paginator
+    // in feature tests, so we only assert the page renders without error.
+    // Full pagination behaviour is verified via e2e tests.
+    Tag::factory()->create(['name' => 'Nature', 'slug' => 'nature', 'is_active' => true]);
+
+    $this->get('/tag/nature')->assertOk();
+});
+
+it('includes JSON-LD CollectionPage schema on tag pages', function (): void {
+    Tag::factory()->create(['name' => 'Abstract', 'slug' => 'abstract', 'is_active' => true]);
+
+    $html = $this->get('/tag/abstract')->assertOk()->getContent();
+
+    expect($html)
+        ->toContain('application/ld+json')
+        ->toContain('CollectionPage');
+});
+
+it('supports sort parameter without error', function (): void {
+    Tag::factory()->create(['name' => 'Space', 'slug' => 'space', 'is_active' => true]);
+
+    foreach (['popular', 'latest', 'likes', 'downloads'] as $sort) {
+        $this->get("/tag/space?sort={$sort}")->assertOk();
+    }
+});
--- a/tests/Feature/TagSearchTest.php
+++ b/tests/Feature/TagSearchTest.php
@@ -0,0 +1,89 @@
+<?php
+
+declare(strict_types=1);
+
+use App\Models\Tag;
+use Illuminate\Support\Facades\Cache;
+
+it('returns matching tags from the search endpoint', function (): void {
+    Tag::factory()->create(['name' => 'cityscape', 'slug' => 'cityscape', 'usage_count' => 50, 'is_active' => true]);
+    Tag::factory()->create(['name' => 'city', 'slug' => 'city', 'usage_count' => 100, 'is_active' => true]);
+    Tag::factory()->create(['name' => 'night', 'slug' => 'night', 'usage_count' => 30, 'is_active' => true]);
+
+    $response = $this->getJson('/api/tags/search?q=city');
+
+    $response->assertOk()
+        ->assertJsonStructure(['data' => [['id', 'name', 'slug', 'usage_count']]])
+        ->assertJsonCount(2, 'data');
+
+    // Results sorted by usage_count desc
+    $slugs = collect($response->json('data'))->pluck('slug')->all();
+    expect($slugs[0])->toBe('city');
+});
+
+it('excludes inactive tags from search', function (): void {
+    Tag::factory()->create(['name' => 'hidden', 'slug' => 'hidden', 'usage_count' => 999, 'is_active' => false]);
+
+    $response = $this->getJson('/api/tags/search?q=hidden');
+
+    $response->assertOk()->assertJsonCount(0, 'data');
+});
+
+it('returns popular tags when no query given', function (): void {
+    Tag::factory()->create(['name' => 'top', 'slug' => 'top', 'usage_count' => 500, 'is_active' => true]);
+    Tag::factory()->create(['name' => 'second', 'slug' => 'second', 'usage_count' => 200, 'is_active' => true]);
+
+    $response = $this->getJson('/api/tags/search');
+
+    $response->assertOk()
+        ->assertJsonStructure(['data'])
+        ->assertJsonCount(2, 'data');
+});
+
+it('returns popular tags from the popular endpoint ordered by usage_count', function (): void {
+    Tag::factory()->create(['name' => 'alpha', 'slug' => 'alpha', 'usage_count' => 10, 'is_active' => true]);
+    Tag::factory()->create(['name' => 'beta', 'slug' => 'beta', 'usage_count' => 80, 'is_active' => true]);
+    Tag::factory()->create(['name' => 'gamma', 'slug' => 'gamma', 'usage_count' => 40, 'is_active' => true]);
+
+    $response = $this->getJson('/api/tags/popular?limit=3');
+
+    $response->assertOk()
+        ->assertJsonCount(3, 'data');
+
+    $slugs = collect($response->json('data'))->pluck('slug')->all();
+    expect($slugs[0])->toBe('beta');
+    expect($slugs[1])->toBe('gamma');
+});
+
+it('caches popular tag results', function (): void {
+    Cache::flush();
+
+    Tag::factory()->create(['name' => 'cache-me', 'slug' => 'cache-me', 'usage_count' => 1, 'is_active' => true]);
+
+    $this->getJson('/api/tags/popular?limit=10')->assertOk();
+
+    expect(Cache::has('tags.popular.10'))->toBeTrue();
+});
+
+it('caches search results', function (): void {
+    Cache::flush();
+
+    Tag::factory()->create(['name' => 'searchable', 'slug' => 'searchable', 'usage_count' => 1, 'is_active' => true]);
+
+    $this->getJson('/api/tags/search?q=searchable')->assertOk();
+
+    expect(Cache::has('tags.search.' . md5('searchable')))->toBeTrue();
+});
+
+it('respects the limit parameter on popular endpoint', function (): void {
+    Tag::factory()->count(10)->sequence(fn ($s) => [
+        'name'        => 'tag-' . $s->index,
+        'slug'        => 'tag-' . $s->index,
+        'usage_count' => $s->index,
+        'is_active'   => true,
+    ])->create();
+
+    $response = $this->getJson('/api/tags/popular?limit=3');
+
+    $response->assertOk()->assertJsonCount(3, 'data');
+});