@@ -200,14 +199,17 @@ const shouldShowRegMessage = computed(() => {
Badge orders are currently closed
-
+ :href="route('badges.index')"
+ class="w-full">
+
+
diff --git a/storage/app/.gitignore b/storage/app/.gitignore
old mode 100644
new mode 100755
diff --git a/storage/app/public/.gitignore b/storage/app/public/.gitignore
old mode 100644
new mode 100755
diff --git a/storage/clockwork/.gitignore b/storage/clockwork/.gitignore
old mode 100644
new mode 100755
diff --git a/storage/framework/.gitignore b/storage/framework/.gitignore
old mode 100644
new mode 100755
diff --git a/storage/framework/cache/.gitignore b/storage/framework/cache/.gitignore
old mode 100644
new mode 100755
diff --git a/storage/framework/cache/data/.gitignore b/storage/framework/cache/data/.gitignore
old mode 100644
new mode 100755
diff --git a/storage/framework/sessions/.gitignore b/storage/framework/sessions/.gitignore
old mode 100644
new mode 100755
diff --git a/storage/framework/testing/.gitignore b/storage/framework/testing/.gitignore
old mode 100644
new mode 100755
diff --git a/storage/framework/views/.gitignore b/storage/framework/views/.gitignore
old mode 100644
new mode 100755
diff --git a/storage/logs/.gitignore b/storage/logs/.gitignore
old mode 100644
new mode 100755
diff --git a/tests/Feature/BadgeControllerFlowTest.php b/tests/Feature/BadgeControllerFlowTest.php
new file mode 100644
index 00000000..cb9cb8a2
--- /dev/null
+++ b/tests/Feature/BadgeControllerFlowTest.php
@@ -0,0 +1,471 @@
+user = User::factory()->create([
+ 'has_free_badge' => false,
+ 'free_badge_copies' => 0,
+ ]);
+
+ Storage::fake('local'); // Use local instead of s3 for tests
+ Notification::fake();
+ Http::fake(); // Mock all HTTP requests
+});
+
+describe('Event State: Past Event (CLOSED - Event Ended)', function () {
+ beforeEach(function () {
+ // Event that has ended
+ $this->event = Event::factory()->create([
+ 'starts_at' => now()->subDays(30),
+ 'ends_at' => now()->subDays(1), // Event ended yesterday
+ 'order_starts_at' => now()->subDays(25),
+ 'order_ends_at' => now()->subDays(5),
+ ]);
+ });
+
+ test('getActiveEvent returns null when event has ended', function () {
+ expect(Event::getActiveEvent())->toBeNull();
+ });
+
+ test('event state is CLOSED when event has ended', function () {
+ expect($this->event->state)->toBe(EventStateEnum::CLOSED);
+ expect($this->event->allowsOrders())->toBeFalse();
+ });
+
+ test('badge index shows no create button when event ended', function () {
+ actingAs($this->user);
+
+ $response = get(route('badges.index'));
+
+ $response->assertSuccessful();
+ $response->assertInertia(fn ($page) =>
+ $page->where('canCreate', false)
+ );
+ });
+
+ test('badge creation is forbidden when event has ended', function () {
+ actingAs($this->user);
+
+ get(route('badges.create'))->assertForbidden();
+
+ post(route('badges.store'), [
+ 'species' => 'Wolf',
+ 'name' => 'Test Badge',
+ 'image' => UploadedFile::fake()->image('test.png', 400, 400),
+ 'catchEmAll' => true,
+ 'publish' => true,
+ 'tos' => true,
+ 'upgrades' => ['spareCopy' => false],
+ ])->assertForbidden();
+ });
+});
+
+describe('Event State: External Purchase Period (CLOSED - Pre-Event)', function () {
+ beforeEach(function () {
+ // Event hasn't started yet
+ $this->event = Event::factory()->create([
+ 'starts_at' => now()->addDays(10),
+ 'ends_at' => now()->addDays(40),
+ 'order_starts_at' => now()->addDays(15),
+ 'order_ends_at' => now()->addDays(35),
+ ]);
+ });
+
+ test('getActiveEvent returns null when event exists but hasnt started', function () {
+ expect(Event::getActiveEvent())->toBeNull();
+ });
+
+ test('event state is CLOSED when event hasnt started', function () {
+ expect($this->event->state)->toBe(EventStateEnum::CLOSED);
+ expect($this->event->allowsOrders())->toBeFalse();
+ });
+
+ test('badge creation is forbidden when event hasnt started', function () {
+ actingAs($this->user);
+
+ get(route('badges.create'))->assertForbidden();
+
+ post(route('badges.store'), [
+ 'species' => 'Wolf',
+ 'name' => 'Test Badge',
+ 'image' => UploadedFile::fake()->image('test.png', 400, 400),
+ 'catchEmAll' => true,
+ 'publish' => true,
+ 'tos' => true,
+ 'upgrades' => ['spareCopy' => false],
+ ])->assertForbidden();
+ });
+
+ test('badge index shows existing badges but no create button', function () {
+ // Create a badge from a previous event/session
+ $badge = Badge::factory()
+ ->recycle($this->event)
+ ->recycle($this->user)
+ ->create();
+
+ actingAs($this->user);
+
+ $response = get(route('badges.index'));
+
+ $response->assertSuccessful();
+ $response->assertInertia(fn ($page) =>
+ $page->where('canCreate', false)
+ ->has('badges', 1)
+ );
+ });
+});
+
+describe('Event State: External Purchase Period (CLOSED - Order Window Not Started)', function () {
+ beforeEach(function () {
+ // Event started but order window hasn't
+ $this->event = Event::factory()->create([
+ 'starts_at' => now()->subDays(5),
+ 'ends_at' => now()->addDays(25),
+ 'order_starts_at' => now()->addDays(5), // Orders start in 5 days
+ 'order_ends_at' => now()->addDays(20),
+ ]);
+ });
+
+ test('event state is CLOSED when order window hasnt started', function () {
+ expect($this->event->state)->toBe(EventStateEnum::CLOSED);
+ expect($this->event->allowsOrders())->toBeFalse();
+ });
+
+ test('badge creation is forbidden when order window hasnt started', function () {
+ actingAs($this->user);
+
+ get(route('badges.create'))->assertForbidden();
+ });
+});
+
+describe('Event State: Onsite Purchase Period (OPEN - During Event)', function () {
+ beforeEach(function () {
+ // Event is active and in order window
+ $this->event = Event::factory()->create([
+ 'starts_at' => now()->subDays(2),
+ 'ends_at' => now()->addDays(28),
+ 'order_starts_at' => now()->subDays(1),
+ 'order_ends_at' => now()->addDays(25),
+ ]);
+ });
+
+ test('getActiveEvent returns correct event when active', function () {
+ expect(Event::getActiveEvent())->not->toBeNull();
+ expect(Event::getActiveEvent()->id)->toBe($this->event->id);
+ });
+
+ test('event state is OPEN during active order window', function () {
+ expect($this->event->state)->toBe(EventStateEnum::OPEN);
+ expect($this->event->allowsOrders())->toBeTrue();
+ });
+
+ test('badge index shows create button when orders are open', function () {
+ actingAs($this->user);
+
+ $response = get(route('badges.index'));
+
+ $response->assertSuccessful();
+ $response->assertInertia(fn ($page) =>
+ $page->where('canCreate', true)
+ );
+ });
+
+ test('user can access badge creation form when orders are open', function () {
+ actingAs($this->user);
+
+ $response = get(route('badges.create'));
+
+ $response->assertSuccessful();
+ $response->assertInertia(fn ($page) =>
+ $page->component('Badges/BadgesCreate')
+ ->where('isFree', false)
+ ->where('freeBadgeCopies', 0)
+ );
+ });
+
+ test('user can create badge when orders are open', function () {
+ actingAs($this->user);
+
+ $response = post(route('badges.store'), [
+ 'species' => 'Wolf',
+ 'name' => 'Test Badge',
+ 'image' => UploadedFile::fake()->image('test.png', 400, 400),
+ 'catchEmAll' => true,
+ 'publish' => true,
+ 'tos' => true,
+ 'upgrades' => [
+ 'spareCopy' => false,
+ ],
+ ]);
+
+ $response->assertSessionHasNoErrors();
+ $response->assertRedirect(route('badges.index'));
+
+ $this->assertDatabaseHas('fursuits', [
+ 'name' => 'Test Badge',
+ 'catch_em_all' => true,
+ 'published' => true,
+ ]);
+
+ $this->assertDatabaseHas('badges', [
+ 'total' => 200, // 2€ in cents
+ ]);
+ });
+
+ test('user with free badge can claim it', function () {
+ $this->user->update([
+ 'has_free_badge' => true,
+ 'free_badge_copies' => 0,
+ ]);
+
+ actingAs($this->user);
+
+ $response = get(route('badges.create'));
+
+ $response->assertInertia(fn ($page) =>
+ $page->where('isFree', true)
+ ->where('freeBadgeCopies', 0)
+ );
+
+ $response = post(route('badges.store'), [
+ 'species' => 'Fox',
+ 'name' => 'Free Badge',
+ 'image' => UploadedFile::fake()->image('test.png', 400, 400),
+ 'catchEmAll' => true,
+ 'publish' => true,
+ 'tos' => true,
+ 'upgrades' => [
+ 'spareCopy' => false,
+ ],
+ ]);
+
+ $response->assertSessionHasNoErrors();
+
+ $this->assertDatabaseHas('badges', [
+ 'total' => 0, // Free badge
+ 'is_free_badge' => true,
+ ]);
+
+ // User should no longer have free badge flag
+ $this->user->refresh();
+ expect($this->user->has_free_badge)->toBeFalse();
+ });
+
+ test('user with additional free badge copies can claim them', function () {
+ $this->user->update([
+ 'has_free_badge' => true,
+ 'free_badge_copies' => 2,
+ ]);
+
+ actingAs($this->user);
+
+ $response = get(route('badges.create'));
+
+ $response->assertInertia(fn ($page) =>
+ $page->where('isFree', true)
+ ->where('freeBadgeCopies', 2)
+ );
+
+ $response = post(route('badges.store'), [
+ 'species' => 'Dragon',
+ 'name' => 'Free with Copies',
+ 'image' => UploadedFile::fake()->image('test.png', 400, 400),
+ 'catchEmAll' => true,
+ 'publish' => true,
+ 'tos' => true,
+ 'upgrades' => [
+ 'spareCopy' => true, // This should create additional copies
+ ],
+ ]);
+
+ $response->assertSessionHasNoErrors();
+
+ // Should have main badge (free) + 2 copies
+ $this->assertDatabaseCount('badges', 3);
+
+ // Main badge should be free
+ $mainBadge = Badge::where('is_free_badge', true)->first();
+ expect($mainBadge->total)->toBe(0);
+
+ // Extra copies should exist
+ $extraBadges = Badge::where('extra_copy', true)->get();
+ expect($extraBadges)->toHaveCount(2);
+
+ // User should no longer have free copies
+ $this->user->refresh();
+ expect($this->user->free_badge_copies)->toBe(0);
+ });
+
+ test('user can edit pending badges during order window', function () {
+ $badge = Badge::factory()
+ ->recycle($this->event)
+ ->recycle($this->user)
+ ->create([
+ 'status_fulfillment' => \App\Models\Badge\State_Fulfillment\Pending::$name,
+ ]);
+
+ actingAs($this->user);
+
+ $response = get(route('badges.edit', $badge));
+ $response->assertSuccessful();
+
+ $response = put(route('badges.update', $badge), [
+ 'species' => 'Updated Species',
+ 'name' => 'Updated Name',
+ 'publish' => true,
+ 'catchEmAll' => false,
+ ]);
+
+ $response->assertRedirect(route('badges.index'));
+ $response->assertSessionHasNoErrors();
+
+ $this->assertDatabaseHas('fursuits', [
+ 'name' => 'Updated Name',
+ ]);
+ });
+
+ test('user can delete pending badges during order window', function () {
+ $badge = Badge::factory()
+ ->recycle($this->event)
+ ->recycle($this->user)
+ ->create([
+ 'status_fulfillment' => \App\Models\Badge\State_Fulfillment\Pending::$name,
+ ]);
+
+ actingAs($this->user);
+
+ $response = delete(route('badges.destroy', $badge));
+
+ $response->assertRedirect(route('welcome'));
+
+ $this->assertTrue($badge->fresh()->trashed());
+ });
+
+ test('user cannot edit printed badges', function () {
+ $badge = Badge::factory()
+ ->recycle($this->event)
+ ->recycle($this->user)
+ ->create([
+ 'status_fulfillment' => \App\Models\Badge\State_Fulfillment\Printed::$name,
+ ]);
+
+ actingAs($this->user);
+
+ get(route('badges.edit', $badge))->assertForbidden();
+
+ put(route('badges.update', $badge), [
+ 'species' => 'Cat',
+ 'name' => 'Should Not Update',
+ 'catchEmAll' => true,
+ 'publish' => true,
+ ])->assertForbidden();
+
+ delete(route('badges.destroy', $badge))->assertForbidden();
+ });
+});
+
+describe('Event State: Return to Closed State (Order Window Ended)', function () {
+ beforeEach(function () {
+ // Event is active but order window has ended
+ $this->event = Event::factory()->create([
+ 'starts_at' => now()->subDays(10),
+ 'ends_at' => now()->addDays(20),
+ 'order_starts_at' => now()->subDays(8),
+ 'order_ends_at' => now()->subDays(1), // Orders ended yesterday
+ ]);
+ });
+
+ test('event state is CLOSED when order window has ended', function () {
+ expect($this->event->state)->toBe(EventStateEnum::CLOSED);
+ expect($this->event->allowsOrders())->toBeFalse();
+ });
+
+ test('badge creation is forbidden when order window has ended', function () {
+ actingAs($this->user);
+
+ get(route('badges.create'))->assertForbidden();
+
+ post(route('badges.store'), [
+ 'species' => 'Wolf',
+ 'name' => 'Test Badge',
+ 'image' => UploadedFile::fake()->image('test.png', 400, 400),
+ 'catchEmAll' => true,
+ 'publish' => true,
+ 'tos' => true,
+ 'upgrades' => ['spareCopy' => false],
+ ])->assertForbidden();
+ });
+
+ test('existing badges can still be viewed when order window has ended', function () {
+ $badge = Badge::factory()
+ ->recycle($this->event)
+ ->recycle($this->user)
+ ->create();
+
+ actingAs($this->user);
+
+ $response = get(route('badges.index'));
+
+ $response->assertSuccessful();
+ $response->assertInertia(fn ($page) =>
+ $page->where('canCreate', false)
+ ->has('badges', 1)
+ );
+ });
+});
+
+describe('Multiple Events Handling', function () {
+ test('getActiveEvent returns correct event when multiple events exist', function () {
+ // Past event
+ Event::factory()->create([
+ 'starts_at' => now()->subDays(60),
+ 'ends_at' => now()->subDays(30),
+ ]);
+
+ // Current active event
+ $activeEvent = Event::factory()->create([
+ 'starts_at' => now()->subDays(5),
+ 'ends_at' => now()->addDays(25),
+ ]);
+
+ // Future event
+ Event::factory()->create([
+ 'starts_at' => now()->addDays(60),
+ 'ends_at' => now()->addDays(90),
+ ]);
+
+ expect(Event::getActiveEvent()->id)->toBe($activeEvent->id);
+ });
+
+ test('getActiveEvent returns null when no active events exist', function () {
+ // Only past events
+ Event::factory()->create([
+ 'starts_at' => now()->subDays(60),
+ 'ends_at' => now()->subDays(30),
+ ]);
+
+ Event::factory()->create([
+ 'starts_at' => now()->subDays(90),
+ 'ends_at' => now()->subDays(61),
+ ]);
+
+ expect(Event::getActiveEvent())->toBeNull();
+ });
+});
diff --git a/tests/Feature/BadgeControllerFlowTestFixed.php b/tests/Feature/BadgeControllerFlowTestFixed.php
new file mode 100644
index 00000000..ccb08be1
--- /dev/null
+++ b/tests/Feature/BadgeControllerFlowTestFixed.php
@@ -0,0 +1,329 @@
+user = User::factory()->create([
+ 'has_free_badge' => false,
+ 'free_badge_copies' => 0,
+ ]);
+
+ Storage::fake('local');
+ Notification::fake();
+ Http::fake(); // Mock all HTTP requests
+});
+
+describe('Badge Controller Flow - No Active Event', function () {
+ test('badge routes redirect to welcome when no active event exists', function () {
+ // No events at all
+ actingAs($this->user);
+
+ // EventEndedMiddleware redirects to welcome when no active event
+ get(route('badges.index'))->assertRedirect(route('welcome'));
+ get(route('badges.create'))->assertRedirect(route('welcome'));
+
+ post(route('badges.store'), [
+ 'species' => 'Wolf',
+ 'name' => 'Test Badge',
+ 'image' => UploadedFile::fake()->image('test.png', 400, 400),
+ 'catchEmAll' => true,
+ 'publish' => true,
+ 'tos' => true,
+ 'upgrades' => ['spareCopy' => false],
+ ])->assertRedirect(route('welcome'));
+ });
+
+ test('badge routes redirect when event has ended', function () {
+ // Create an event that has ended
+ Event::factory()->create([
+ 'starts_at' => now()->subDays(30),
+ 'ends_at' => now()->subDays(1), // Event ended yesterday
+ 'order_starts_at' => now()->subDays(25),
+ 'order_ends_at' => now()->subDays(5),
+ ]);
+
+ actingAs($this->user);
+
+ // EventEndedMiddleware redirects to welcome when no active event
+ get(route('badges.index'))->assertRedirect(route('welcome'));
+ get(route('badges.create'))->assertRedirect(route('welcome'));
+ });
+});
+
+describe('Badge Controller Flow - Event Active, Orders Closed', function () {
+ beforeEach(function () {
+ // Event exists but order window hasn't started
+ $this->event = Event::factory()->create([
+ 'starts_at' => now()->addDays(10),
+ 'ends_at' => now()->addDays(40),
+ 'order_starts_at' => now()->addDays(15),
+ 'order_ends_at' => now()->addDays(35),
+ ]);
+ });
+
+ test('event state is CLOSED when order window hasnt started', function () {
+ expect($this->event->state)->toBe(EventStateEnum::CLOSED);
+ expect($this->event->allowsOrders())->toBeFalse();
+ });
+
+ test('badge index is accessible but shows no create button', function () {
+ actingAs($this->user);
+
+ $response = get(route('badges.index'));
+
+ $response->assertSuccessful();
+ $response->assertInertia(fn ($page) =>
+ $page->where('canCreate', false)
+ );
+ });
+
+ test('badge creation is forbidden when orders are closed', function () {
+ actingAs($this->user);
+
+ // Policy should prevent creation
+ $response = get(route('badges.create'));
+ $response->assertStatus(403);
+
+ $response = post(route('badges.store'), [
+ 'species' => 'Wolf',
+ 'name' => 'Test Badge',
+ 'image' => UploadedFile::fake()->image('test.png', 400, 400),
+ 'catchEmAll' => true,
+ 'publish' => true,
+ 'tos' => true,
+ 'upgrades' => ['spareCopy' => false],
+ ]);
+ $response->assertStatus(403);
+ });
+});
+
+describe('Badge Controller Flow - Event Active, Orders Open', function () {
+ beforeEach(function () {
+ // Event is active and within order window
+ $this->event = Event::factory()->create([
+ 'starts_at' => now()->subDays(2),
+ 'ends_at' => now()->addDays(28),
+ 'order_starts_at' => now()->subDays(1),
+ 'order_ends_at' => now()->addDays(25),
+ ]);
+ });
+
+ test('getActiveEvent returns correct event', function () {
+ $activeEvent = Event::getActiveEvent();
+ expect($activeEvent)->not->toBeNull();
+ expect($activeEvent->id)->toBe($this->event->id);
+ });
+
+ test('event state is OPEN during active order window', function () {
+ expect($this->event->state)->toBe(EventStateEnum::OPEN);
+ expect($this->event->allowsOrders())->toBeTrue();
+ });
+
+ test('badge index shows create button when orders are allowed', function () {
+ actingAs($this->user);
+
+ $response = get(route('badges.index'));
+
+ $response->assertSuccessful();
+ $response->assertInertia(fn ($page) =>
+ $page->where('canCreate', true)
+ );
+ });
+
+ test('user can access badge creation form', function () {
+ actingAs($this->user);
+
+ $response = get(route('badges.create'));
+
+ $response->assertSuccessful();
+ $response->assertInertia(fn ($page) =>
+ $page->component('Badges/BadgesCreate')
+ );
+ });
+
+ test('user can create regular badge when orders are allowed', function () {
+ actingAs($this->user);
+
+ $response = post(route('badges.store'), [
+ 'species' => 'Wolf',
+ 'name' => 'Test Badge',
+ 'image' => UploadedFile::fake()->image('test.png', 400, 400),
+ 'catchEmAll' => true,
+ 'publish' => true,
+ 'tos' => true,
+ 'upgrades' => ['spareCopy' => false],
+ ]);
+
+ $response->assertRedirect(route('badges.index'));
+
+ $this->assertDatabaseHas('badges', [
+ 'is_free_badge' => false,
+ ]);
+ });
+
+ test('user with free badge can claim it', function () {
+ $this->user->update([
+ 'has_free_badge' => true,
+ 'free_badge_copies' => 0,
+ ]);
+
+ actingAs($this->user);
+
+ $response = post(route('badges.store'), [
+ 'species' => 'Cat',
+ 'name' => 'Free Badge',
+ 'image' => UploadedFile::fake()->image('test.png', 400, 400),
+ 'catchEmAll' => true,
+ 'publish' => true,
+ 'tos' => true,
+ 'upgrades' => ['spareCopy' => false],
+ ]);
+
+ $response->assertRedirect(route('badges.index'));
+
+ $this->assertDatabaseHas('badges', [
+ 'total' => 0, // Free badge
+ 'is_free_badge' => true,
+ ]);
+
+ // User should no longer have free badge available
+ $this->user->refresh();
+ expect($this->user->has_free_badge)->toBeFalse();
+ });
+
+ test('user can edit pending badges during order window', function () {
+ $badge = Badge::factory()
+ ->recycle($this->event)
+ ->recycle($this->user)
+ ->create([
+ 'status_fulfillment' => \App\Models\Badge\State_Fulfillment\Pending::$name,
+ ]);
+
+ actingAs($this->user);
+
+ $response = get(route('badges.edit', $badge));
+ $response->assertSuccessful();
+ });
+
+ test('user cannot edit printed badges', function () {
+ $badge = Badge::factory()
+ ->recycle($this->event)
+ ->recycle($this->user)
+ ->create([
+ 'status_fulfillment' => \App\Models\Badge\State_Fulfillment\Printed::$name,
+ ]);
+
+ actingAs($this->user);
+
+ get(route('badges.edit', $badge))->assertStatus(403);
+
+ put(route('badges.update', $badge), [
+ 'species' => 'Cat',
+ 'name' => 'Should Not Update',
+ 'catchEmAll' => true,
+ 'publish' => true,
+ ])->assertStatus(403);
+ });
+});
+
+describe('Badge Controller Flow - Order Window Ended', function () {
+ beforeEach(function () {
+ // Event is still active but order window has ended
+ $this->event = Event::factory()->create([
+ 'starts_at' => now()->subDays(10),
+ 'ends_at' => now()->addDays(20),
+ 'order_starts_at' => now()->subDays(8),
+ 'order_ends_at' => now()->subDays(1), // Order window ended yesterday
+ ]);
+ });
+
+ test('event state is CLOSED when order window has ended', function () {
+ expect($this->event->state)->toBe(EventStateEnum::CLOSED);
+ expect($this->event->allowsOrders())->toBeFalse();
+ });
+
+ test('badge creation is forbidden when order window has ended', function () {
+ actingAs($this->user);
+
+ get(route('badges.create'))->assertStatus(403);
+
+ post(route('badges.store'), [
+ 'species' => 'Wolf',
+ 'name' => 'Test Badge',
+ 'image' => UploadedFile::fake()->image('test.png', 400, 400),
+ 'catchEmAll' => true,
+ 'publish' => true,
+ 'tos' => true,
+ 'upgrades' => ['spareCopy' => false],
+ ])->assertStatus(403);
+ });
+
+ test('existing badges can still be viewed when order window has ended', function () {
+ $badge = Badge::factory()
+ ->recycle($this->event)
+ ->recycle($this->user)
+ ->create();
+
+ actingAs($this->user);
+
+ $response = get(route('badges.index'));
+
+ $response->assertSuccessful();
+ $response->assertInertia(fn ($page) =>
+ $page->where('badges', fn ($badges) => count($badges) === 1)
+ );
+ });
+});
+
+describe('Multiple Events Handling', function () {
+ test('getActiveEvent returns correct event when multiple events exist', function () {
+ // Create multiple events
+ $pastEvent = Event::factory()->create([
+ 'starts_at' => now()->subDays(60),
+ 'ends_at' => now()->subDays(30),
+ ]);
+
+ $activeEvent = Event::factory()->create([
+ 'starts_at' => now()->subDays(5),
+ 'ends_at' => now()->addDays(25),
+ ]);
+
+ $futureEvent = Event::factory()->create([
+ 'starts_at' => now()->addDays(40),
+ 'ends_at' => now()->addDays(70),
+ ]);
+
+ $result = Event::getActiveEvent();
+ expect($result?->id)->toBe($activeEvent->id);
+ });
+
+ test('getActiveEvent returns null when no active events exist', function () {
+ // Create only past and future events
+ Event::factory()->create([
+ 'starts_at' => now()->subDays(60),
+ 'ends_at' => now()->subDays(30),
+ ]);
+
+ Event::factory()->create([
+ 'starts_at' => now()->addDays(40),
+ 'ends_at' => now()->addDays(70),
+ ]);
+
+ expect(Event::getActiveEvent())->toBeNull();
+ });
+});
diff --git a/tests/Feature/BadgeTest.php b/tests/Feature/BadgeTest.php
index 4384d7df..1fdff703 100644
--- a/tests/Feature/BadgeTest.php
+++ b/tests/Feature/BadgeTest.php
@@ -6,6 +6,7 @@
use Illuminate\Http\UploadedFile;
use Illuminate\Support\Facades\Notification;
use Illuminate\Support\Facades\Storage;
+use Illuminate\Support\Facades\Http;
use function Pest\Laravel\actingAs;
use function Pest\Laravel\post;
use function Pest\Laravel\put;
@@ -27,7 +28,8 @@
'order_ends_at' => \Carbon\Carbon::parse('2024-06-25'),
]);
// Fake Storage
- Storage::fake('s3');
+ Storage::fake('local'); // Use local instead of s3 for tests
+ Http::fake(); // Mock all HTTP requests
});
test('user can create badge', function () {
@@ -35,7 +37,7 @@
Notification::fake();
// Travel to valid time
- travelTo(\Carbon\Carbon::parse('2024-05-02'));
+ travelTo(\Carbon\Carbon::parse('2024-06-02'));
actingAs($this->user);
$response = post(route('badges.store'), [
'species' => 'Wolf',
@@ -66,7 +68,7 @@
// Get the badge from db
$badge = Badge::first();
// check if image was uploaded
- Storage::disk('s3')->assertExists($badge->image);
+ Storage::assertExists($badge->fursuit->image);
// Check notification was sent
Notification::assertSentTo($this->user, \App\Notifications\BadgeCreatedNotification::class);
});
@@ -103,7 +105,7 @@
'doubleSided' => true,
'spareCopy' => true,
],
- ])->assertRedirect(route('welcome'));
+ ])->assertForbidden();
});
test('user cannot update badge when event has ended', function () {
@@ -114,6 +116,9 @@
travelTo(\Carbon\Carbon::parse('2024-07-01'));
actingAs($this->user);
putJson(route('badges.update', $badge->id), [
+ 'species' => 'Wolf',
'name' => 'Updated Badge Name',
- ])->assertRedirect(route('welcome'));
+ 'catchEmAll' => true,
+ 'publish' => true,
+ ])->assertForbidden();
});
diff --git a/tests/Feature/WelcomePageFlowTest.php b/tests/Feature/WelcomePageFlowTest.php
new file mode 100644
index 00000000..b218a0f8
--- /dev/null
+++ b/tests/Feature/WelcomePageFlowTest.php
@@ -0,0 +1,234 @@
+user = User::factory()->create([
+ 'has_free_badge' => false,
+ 'free_badge_copies' => 0,
+ ]);
+});
+
+describe('Welcome Page Flow States', function () {
+ test('shows closed state when no active event exists', function () {
+ // No events exist
+ $response = get(route('welcome'));
+
+ $response->assertSuccessful();
+ $response->assertInertia(fn ($page) =>
+ $page->component('Welcome')
+ ->where('showState', EventStateEnum::CLOSED->value)
+ );
+ });
+
+ test('shows closed state when event has ended', function () {
+ Event::factory()->create([
+ 'starts_at' => now()->subDays(30),
+ 'ends_at' => now()->subDays(1),
+ 'order_starts_at' => now()->subDays(25),
+ 'order_ends_at' => now()->subDays(5),
+ ]);
+
+ $response = get(route('welcome'));
+
+ $response->assertSuccessful();
+ $response->assertInertia(fn ($page) =>
+ $page->where('showState', EventStateEnum::CLOSED->value)
+ );
+ });
+
+ test('shows closed state when event hasnt started', function () {
+ Event::factory()->create([
+ 'starts_at' => now()->addDays(10),
+ 'ends_at' => now()->addDays(40),
+ 'order_starts_at' => now()->addDays(15),
+ 'order_ends_at' => now()->addDays(35),
+ ]);
+
+ $response = get(route('welcome'));
+
+ $response->assertSuccessful();
+ $response->assertInertia(fn ($page) =>
+ $page->where('showState', EventStateEnum::CLOSED->value)
+ );
+ });
+
+ test('shows closed state when order window hasnt started', function () {
+ Event::factory()->create([
+ 'starts_at' => now()->subDays(5),
+ 'ends_at' => now()->addDays(25),
+ 'order_starts_at' => now()->addDays(5),
+ 'order_ends_at' => now()->addDays(20),
+ ]);
+
+ $response = get(route('welcome'));
+
+ $response->assertSuccessful();
+ $response->assertInertia(fn ($page) =>
+ $page->where('showState', EventStateEnum::CLOSED->value)
+ );
+ });
+
+ test('shows closed state when order window has ended', function () {
+ Event::factory()->create([
+ 'starts_at' => now()->subDays(10),
+ 'ends_at' => now()->addDays(20),
+ 'order_starts_at' => now()->subDays(8),
+ 'order_ends_at' => now()->subDays(1),
+ ]);
+
+ $response = get(route('welcome'));
+
+ $response->assertSuccessful();
+ $response->assertInertia(fn ($page) =>
+ $page->where('showState', EventStateEnum::CLOSED->value)
+ );
+ });
+
+ test('shows open state when in order window', function () {
+ Event::factory()->create([
+ 'starts_at' => now()->subDays(2),
+ 'ends_at' => now()->addDays(28),
+ 'order_starts_at' => now()->subDays(1),
+ 'order_ends_at' => now()->addDays(25),
+ ]);
+
+ $response = get(route('welcome'));
+
+ $response->assertSuccessful();
+ $response->assertInertia(fn ($page) =>
+ $page->where('showState', EventStateEnum::OPEN->value)
+ );
+ });
+});
+
+describe('Welcome Page User Interface States', function () {
+ beforeEach(function () {
+ // Create an active event for these tests
+ $this->event = Event::factory()->create([
+ 'starts_at' => now()->subDays(2),
+ 'ends_at' => now()->addDays(28),
+ 'order_starts_at' => now()->subDays(1),
+ 'order_ends_at' => now()->addDays(25),
+ ]);
+ });
+
+ test('shows login button when user is not authenticated', function () {
+ $response = get(route('welcome'));
+
+ $response->assertSuccessful();
+ // When not authenticated, user data is null
+ $response->assertInertia(fn ($page) =>
+ $page->where('auth.user', null)
+ );
+ });
+
+ test('shows appropriate buttons for user with no badges', function () {
+ actingAs($this->user);
+
+ $response = get(route('welcome'));
+
+ $response->assertSuccessful();
+ $response->assertInertia(fn ($page) =>
+ $page->where('auth.user.id', $this->user->id)
+ ->where('auth.user.has_free_badge', false)
+ ->where('auth.user.free_badge_copies', 0)
+ );
+ });
+
+ test('shows appropriate buttons for user with free badge', function () {
+ $this->user->update([
+ 'has_free_badge' => true,
+ 'free_badge_copies' => 0,
+ ]);
+
+ actingAs($this->user);
+
+ $response = get(route('welcome'));
+
+ $response->assertSuccessful();
+ $response->assertInertia(fn ($page) =>
+ $page->where('auth.user.has_free_badge', true)
+ ->where('auth.user.free_badge_copies', 0)
+ );
+ });
+
+ test('shows appropriate buttons for user with additional free badges', function () {
+ $this->user->update([
+ 'has_free_badge' => true,
+ 'free_badge_copies' => 3,
+ ]);
+
+ actingAs($this->user);
+
+ $response = get(route('welcome'));
+
+ $response->assertSuccessful();
+ $response->assertInertia(fn ($page) =>
+ $page->where('auth.user.has_free_badge', true)
+ ->where('auth.user.free_badge_copies', 3)
+ );
+ });
+
+ test('shows badges count for user with existing badges', function () {
+ // Create some badges for the user
+ \App\Models\Badge\Badge::factory()
+ ->count(2)
+ ->recycle($this->event)
+ ->recycle($this->user)
+ ->create();
+
+ actingAs($this->user);
+
+ $response = get(route('welcome'));
+
+ $response->assertSuccessful();
+ $response->assertInertia(fn ($page) =>
+ $page->where('auth.user.badges', fn ($badges) => count($badges) === 2)
+ );
+ });
+});
+
+describe('Welcome Page Mass Print Detection', function () {
+ test('shows mass print message when badges were printed early', function () {
+ $event = Event::factory()->create([
+ 'starts_at' => now()->subDays(2),
+ 'ends_at' => now()->addDays(28),
+ 'order_starts_at' => now()->subDays(1),
+ 'order_ends_at' => now()->addDays(25),
+ 'mass_printed_at' => now()->subDays(3), // Printed before current time
+ ]);
+
+ $response = get(route('welcome'));
+
+ $response->assertSuccessful();
+ // The Vue component will check this condition client-side
+ $response->assertInertia(fn ($page) =>
+ $page->where('event.mass_printed_at', $event->mass_printed_at->toISOString())
+ );
+ });
+
+ test('does not show mass print message when badges not yet printed', function () {
+ $event = Event::factory()->create([
+ 'starts_at' => now()->subDays(2),
+ 'ends_at' => now()->addDays(28),
+ 'order_starts_at' => now()->subDays(1),
+ 'order_ends_at' => now()->addDays(25),
+ 'mass_printed_at' => now()->addDays(5), // Will be printed in future
+ ]);
+
+ $response = get(route('welcome'));
+
+ $response->assertSuccessful();
+ $response->assertInertia(fn ($page) =>
+ $page->where('event.mass_printed_at', $event->mass_printed_at->toISOString())
+ );
+ });
+});