Implement package limit notification system

tests/Feature/Api/EventGuestUploadLimitTest.php

@@ -0,0 +1,134 @@
+<?php
+
+namespace Tests\Feature\Api;
+
+use App\Jobs\Packages\SendEventPackagePhotoLimitNotification;
+use App\Jobs\Packages\SendEventPackagePhotoThresholdWarning;
+use App\Models\Emotion;
+use App\Models\Event;
+use App\Models\EventPackage;
+use App\Models\MediaStorageTarget;
+use App\Models\Package;
+use App\Models\Tenant;
+use App\Services\EventJoinTokenService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Http\UploadedFile;
+use Illuminate\Support\Facades\Bus;
+use Illuminate\Support\Facades\Config;
+use Illuminate\Support\Facades\Storage;
+use Tests\TestCase;
+
+class EventGuestUploadLimitTest extends TestCase
+{
+    use RefreshDatabase;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+        Config::set('filesystems.default', 'local');
+        Storage::fake('local');
+
+        MediaStorageTarget::query()->create([
+            'key' => 'local',
+            'name' => 'Local',
+            'driver' => 'local',
+            'config' => [],
+            'is_hot' => true,
+            'is_default' => true,
+            'is_active' => true,
+            'priority' => 1,
+        ]);
+    }
+
+    public function test_guest_upload_blocked_when_photo_limit_reached(): void
+    {
+        Bus::fake();
+
+        $tenant = Tenant::factory()->create();
+        $event = Event::factory()->for($tenant)->create([
+            'status' => 'published',
+        ]);
+
+        $package = Package::factory()->endcustomer()->create([
+            'max_photos' => 1,
+            'max_guests' => null,
+        ]);
+
+        EventPackage::create([
+            'event_id' => $event->id,
+            'package_id' => $package->id,
+            'purchased_price' => $package->price,
+            'purchased_at' => now(),
+            'used_photos' => 1,
+            'used_guests' => 0,
+            'gallery_expires_at' => now()->addDays(7),
+        ]);
+
+        $emotion = Emotion::factory()->create();
+        $emotion->eventTypes()->attach($event->event_type_id);
+
+        /** @var EventJoinTokenService $tokenService */
+        $tokenService = $this->app->make(EventJoinTokenService::class);
+        $joinToken = $tokenService->createToken($event, ['label' => 'Test']);
+        $token = $joinToken->plain_token;
+
+        $response = $this->post("/api/v1/events/{$token}/upload", [
+            'photo' => UploadedFile::fake()->image('limit.jpg', 800, 600),
+        ], [
+            'X-Device-Id' => 'device-123',
+        ]);
+
+        $response->assertStatus(402);
+        $response->assertJsonPath('error.code', 'photo_limit_exceeded');
+
+        Bus::assertNothingDispatched();
+    }
+
+    public function test_guest_upload_increments_usage_and_succeeds(): void
+    {
+        Bus::fake();
+
+        $tenant = Tenant::factory()->create();
+        $event = Event::factory()->for($tenant)->create([
+            'status' => 'published',
+        ]);
+
+        $package = Package::factory()->endcustomer()->create([
+            'max_photos' => 2,
+            'max_guests' => null,
+        ]);
+
+        $eventPackage = EventPackage::create([
+            'event_id' => $event->id,
+            'package_id' => $package->id,
+            'purchased_price' => $package->price,
+            'purchased_at' => now(),
+            'used_photos' => 1,
+            'used_guests' => 0,
+            'gallery_expires_at' => now()->addDays(7),
+        ]);
+
+        $emotion = Emotion::factory()->create();
+        $emotion->eventTypes()->attach($event->event_type_id);
+
+        /** @var EventJoinTokenService $tokenService */
+        $tokenService = $this->app->make(EventJoinTokenService::class);
+        $token = $tokenService->createToken($event, ['label' => 'Test'])->plain_token;
+
+        $response = $this->post("/api/v1/events/{$token}/upload", [
+            'photo' => UploadedFile::fake()->image('success.jpg', 1024, 768),
+        ], [
+            'X-Device-Id' => 'device-456',
+        ]);
+
+        $response->assertCreated();
+        $this->assertEquals(
+            2,
+            $eventPackage->refresh()->used_photos
+        );
+
+        $thresholdJobs = Bus::dispatched(SendEventPackagePhotoThresholdWarning::class);
+        $this->assertGreaterThanOrEqual(2, $thresholdJobs->count());
+        Bus::assertDispatched(SendEventPackagePhotoLimitNotification::class);
+    }
+}

tests/Feature/Console/CheckEventPackagesCommandTest.php

@@ -0,0 +1,216 @@
+<?php
+
+namespace Tests\Feature\Console;
+
+use App\Console\Commands\CheckEventPackages;
+use App\Events\Packages\EventPackageGalleryExpired;
+use App\Events\Packages\EventPackageGalleryExpiring;
+use App\Events\Packages\TenantCreditsLow;
+use App\Events\Packages\TenantPackageExpired;
+use App\Events\Packages\TenantPackageExpiring;
+use App\Models\Event;
+use App\Models\EventPackage;
+use App\Models\Package;
+use App\Models\Tenant;
+use App\Models\TenantPackage;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Carbon;
+use Illuminate\Support\Facades\Artisan;
+use Illuminate\Support\Facades\Config;
+use Illuminate\Support\Facades\Event as EventFacade;
+use Tests\TestCase;
+
+class CheckEventPackagesCommandTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_dispatches_gallery_warning_and_updates_timestamp(): void
+    {
+        EventFacade::fake();
+
+        $tenant = Tenant::factory()->create();
+        $package = Package::factory()->endcustomer()->create([
+            'max_photos' => 100,
+        ]);
+        $event = Event::factory()->for($tenant)->create();
+
+        $eventPackage = EventPackage::create([
+            'event_id' => $event->id,
+            'package_id' => $package->id,
+            'purchased_price' => $package->price,
+            'purchased_at' => now()->subMonth(),
+            'used_photos' => 10,
+            'used_guests' => 0,
+            'gallery_expires_at' => now()->copy()->addDays(7),
+        ]);
+
+        Artisan::call(CheckEventPackages::class);
+
+        EventFacade::assertDispatched(EventPackageGalleryExpiring::class, function ($event) use ($eventPackage) {
+            return $event->eventPackage->is($eventPackage) && $event->daysRemaining === 7;
+        });
+
+        $this->assertNotNull($eventPackage->fresh()->gallery_warning_sent_at);
+    }
+
+    public function test_dispatches_gallery_expired_and_updates_timestamp(): void
+    {
+        EventFacade::fake();
+
+        $tenant = Tenant::factory()->create();
+        $package = Package::factory()->endcustomer()->create([
+            'max_photos' => 100,
+        ]);
+        $event = Event::factory()->for($tenant)->create();
+
+        $eventPackage = EventPackage::create([
+            'event_id' => $event->id,
+            'package_id' => $package->id,
+            'purchased_price' => $package->price,
+            'purchased_at' => now()->subMonth(),
+            'used_photos' => 10,
+            'used_guests' => 0,
+            'gallery_expires_at' => now()->copy()->subDay(),
+        ]);
+
+        Artisan::call(CheckEventPackages::class);
+
+        EventFacade::assertDispatched(EventPackageGalleryExpired::class, function ($event) use ($eventPackage) {
+            return $event->eventPackage->is($eventPackage);
+        });
+
+        $this->assertNotNull($eventPackage->fresh()->gallery_expired_notified_at);
+    }
+
+    public function test_dispatches_tenant_package_expiry_warning_and_updates_timestamp(): void
+    {
+        EventFacade::fake();
+
+        Config::set('package-limits.package_expiry_days', [6, 1]);
+
+        $now = now()->startOfMinute();
+        Carbon::setTestNow($now);
+
+        try {
+            $tenant = Tenant::factory()->create();
+            $package = Package::factory()->reseller()->create([
+                'max_events_per_year' => 5,
+            ]);
+
+            $tenantPackage = TenantPackage::factory()->for($tenant)->for($package)->create([
+                'expires_at' => $now->copy()->addDays(6),
+                'expiry_warning_sent_at' => null,
+            ]);
+
+            Artisan::call(CheckEventPackages::class);
+
+            EventFacade::assertDispatched(TenantPackageExpiring::class, function ($event) use ($tenantPackage) {
+                return $event->tenantPackage->is($tenantPackage) && $event->daysRemaining === 6;
+            });
+
+            $this->assertNotNull($tenantPackage->fresh()->expiry_warning_sent_at);
+        } finally {
+            Carbon::setTestNow();
+        }
+    }
+
+    public function test_dispatches_tenant_package_expired_and_updates_timestamp(): void
+    {
+        EventFacade::fake();
+
+        $now = now()->startOfMinute();
+        Carbon::setTestNow($now);
+
+        try {
+            $tenant = Tenant::factory()->create();
+            $package = Package::factory()->reseller()->create([
+                'max_events_per_year' => 5,
+            ]);
+
+            $tenantPackage = TenantPackage::factory()->for($tenant)->for($package)->create([
+                'expires_at' => $now->copy()->subDay(),
+                'expired_notified_at' => null,
+            ]);
+
+            Artisan::call(CheckEventPackages::class);
+
+            EventFacade::assertDispatched(TenantPackageExpired::class, function ($event) use ($tenantPackage) {
+                return $event->tenantPackage->is($tenantPackage);
+            });
+
+            $this->assertNotNull($tenantPackage->fresh()->expired_notified_at);
+        } finally {
+            Carbon::setTestNow();
+        }
+    }
+
+    public function test_dispatches_credit_warning_and_sets_threshold(): void
+    {
+        EventFacade::fake();
+
+        Config::set('package-limits.credit_thresholds', [5, 1]);
+
+        $tenant = Tenant::factory()->create([
+            'event_credits_balance' => 5,
+            'credit_warning_sent_at' => null,
+            'credit_warning_threshold' => null,
+        ]);
+
+        Artisan::call(CheckEventPackages::class);
+
+        EventFacade::assertDispatched(TenantCreditsLow::class, function ($event) use ($tenant) {
+            return $event->tenant->is($tenant) && $event->threshold === 5 && $event->balance === 5;
+        });
+
+        $tenant->refresh();
+
+        $this->assertNotNull($tenant->credit_warning_sent_at);
+        $this->assertSame(5, $tenant->credit_warning_threshold);
+    }
+
+    public function test_resets_credit_warning_when_balance_recovers(): void
+    {
+        EventFacade::fake();
+
+        Config::set('package-limits.credit_thresholds', [5, 1]);
+
+        $tenant = Tenant::factory()->create([
+            'event_credits_balance' => 10,
+            'credit_warning_sent_at' => now()->subDay(),
+            'credit_warning_threshold' => 1,
+        ]);
+
+        Artisan::call(CheckEventPackages::class);
+
+        EventFacade::assertNotDispatched(TenantCreditsLow::class);
+
+        $tenant->refresh();
+
+        $this->assertNull($tenant->credit_warning_sent_at);
+        $this->assertNull($tenant->credit_warning_threshold);
+    }
+
+    public function test_dispatches_lower_credit_threshold_after_higher_warning(): void
+    {
+        EventFacade::fake();
+
+        Config::set('package-limits.credit_thresholds', [5, 1]);
+
+        $tenant = Tenant::factory()->create([
+            'event_credits_balance' => 1,
+            'credit_warning_sent_at' => now()->subDay(),
+            'credit_warning_threshold' => 5,
+        ]);
+
+        Artisan::call(CheckEventPackages::class);
+
+        EventFacade::assertDispatched(TenantCreditsLow::class, function ($event) use ($tenant) {
+            return $event->tenant->is($tenant) && $event->threshold === 1;
+        });
+
+        $tenant->refresh();
+
+        $this->assertSame(1, $tenant->credit_warning_threshold);
+        $this->assertNotNull($tenant->credit_warning_sent_at);
+    }
+}

tests/Unit/Services/PackageLimitEvaluatorTest.php

@@ -0,0 +1,128 @@
+<?php
+
+namespace Tests\Unit\Services;
+
+use App\Models\Event;
+use App\Models\EventPackage;
+use App\Models\Package;
+use App\Models\Tenant;
+use App\Models\TenantPackage;
+use App\Services\Packages\PackageLimitEvaluator;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Tests\TestCase;
+
+class PackageLimitEvaluatorTest extends TestCase
+{
+    use RefreshDatabase;
+
+    private PackageLimitEvaluator $evaluator;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+        $this->evaluator = $this->app->make(PackageLimitEvaluator::class);
+    }
+
+    public function test_assess_event_creation_returns_null_when_allowance_available(): void
+    {
+        $tenant = Tenant::factory()->create(['event_credits_balance' => 2]);
+
+        $violation = $this->evaluator->assessEventCreation($tenant);
+
+        $this->assertNull($violation);
+    }
+
+    public function test_assess_event_creation_returns_package_violation_when_quota_reached(): void
+    {
+        $package = Package::factory()->reseller()->create([
+            'max_events_per_year' => 1,
+        ]);
+
+        $tenant = Tenant::factory()->create(['event_credits_balance' => 0]);
+
+        TenantPackage::factory()->create([
+            'tenant_id' => $tenant->id,
+            'package_id' => $package->id,
+            'used_events' => 1,
+            'expires_at' => now()->addMonth(),
+            'active' => true,
+        ]);
+
+        $tenant->refresh();
+
+        $violation = $this->evaluator->assessEventCreation($tenant);
+
+        $this->assertNotNull($violation);
+        $this->assertSame('event_limit_exceeded', $violation['code']);
+        $this->assertSame('events', $violation['meta']['scope']);
+        $this->assertSame(0, $violation['meta']['remaining']);
+    }
+
+    public function test_assess_event_creation_returns_credit_violation_when_no_credits(): void
+    {
+        $tenant = Tenant::factory()->create(['event_credits_balance' => 0]);
+
+        $violation = $this->evaluator->assessEventCreation($tenant);
+
+        $this->assertNotNull($violation);
+        $this->assertSame('event_credits_exhausted', $violation['code']);
+        $this->assertSame('credits', $violation['meta']['scope']);
+    }
+
+    public function test_assess_photo_upload_returns_violation_when_photo_limit_reached(): void
+    {
+        $package = Package::factory()->endcustomer()->create([
+            'max_photos' => 5,
+        ]);
+
+        $tenant = Tenant::factory()->create();
+
+        $event = Event::factory()
+            ->for($tenant)
+            ->create();
+
+        EventPackage::create([
+            'event_id' => $event->id,
+            'package_id' => $package->id,
+            'purchased_price' => $package->price,
+            'purchased_at' => now(),
+            'used_photos' => 5,
+            'used_guests' => 0,
+            'gallery_expires_at' => now()->addDays(14),
+        ]);
+
+        $violation = $this->evaluator->assessPhotoUpload($tenant->fresh(), $event->id);
+
+        $this->assertNotNull($violation);
+        $this->assertSame('photo_limit_exceeded', $violation['code']);
+        $this->assertSame('photos', $violation['meta']['scope']);
+        $this->assertSame(0, $violation['meta']['remaining']);
+    }
+
+    public function test_assess_photo_upload_returns_null_when_below_limit(): void
+    {
+        $package = Package::factory()->endcustomer()->create([
+            'max_photos' => 10,
+        ]);
+
+        $tenant = Tenant::factory()->create();
+
+        $event = Event::factory()
+            ->for($tenant)
+            ->create();
+
+        EventPackage::create([
+            'event_id' => $event->id,
+            'package_id' => $package->id,
+            'purchased_price' => $package->price,
+            'purchased_at' => now(),
+            'used_photos' => 4,
+            'used_guests' => 0,
+            'gallery_expires_at' => now()->addDays(14),
+        ]);
+
+        $violation = $this->evaluator->assessPhotoUpload($tenant->fresh(), $event->id);
+
+        $this->assertNull($violation);
+    }
+}

tests/Unit/Services/PackageUsageTrackerTest.php

@@ -0,0 +1,148 @@
+<?php
+
+namespace Tests\Unit\Services;
+
+use App\Events\Packages\EventPackageGuestLimitReached;
+use App\Events\Packages\EventPackageGuestThresholdReached;
+use App\Events\Packages\EventPackagePhotoLimitReached;
+use App\Events\Packages\EventPackagePhotoThresholdReached;
+use App\Models\Event;
+use App\Models\EventPackage;
+use App\Models\Package;
+use App\Models\Tenant;
+use App\Services\Packages\PackageUsageTracker;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\Event as EventFacade;
+use Tests\TestCase;
+
+class PackageUsageTrackerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_dispatches_threshold_event_when_crossed(): void
+    {
+        EventFacade::fake([
+            EventPackagePhotoThresholdReached::class,
+            EventPackagePhotoLimitReached::class,
+        ]);
+
+        $tenant = Tenant::factory()->create();
+        $package = Package::factory()->endcustomer()->create([
+            'max_photos' => 10,
+        ]);
+        $event = Event::factory()->for($tenant)->create();
+
+        $eventPackage = EventPackage::create([
+            'event_id' => $event->id,
+            'package_id' => $package->id,
+            'purchased_price' => $package->price,
+            'purchased_at' => now(),
+            'used_photos' => 8,
+            'used_guests' => 0,
+            'gallery_expires_at' => now()->addDays(7),
+        ])->fresh(['package']);
+
+        /** @var PackageUsageTracker $tracker */
+        $tracker = app(PackageUsageTracker::class);
+
+        $tracker->recordPhotoUsage($eventPackage, 7, 1);
+
+        EventFacade::assertDispatched(EventPackagePhotoThresholdReached::class);
+        EventFacade::assertNotDispatched(EventPackagePhotoLimitReached::class);
+    }
+
+    public function test_dispatches_limit_event_when_reached(): void
+    {
+        EventFacade::fake([
+            EventPackagePhotoThresholdReached::class,
+            EventPackagePhotoLimitReached::class,
+        ]);
+
+        $tenant = Tenant::factory()->create();
+        $package = Package::factory()->endcustomer()->create([
+            'max_photos' => 2,
+            'max_guests' => null,
+        ]);
+        $event = Event::factory()->for($tenant)->create();
+
+        $eventPackage = EventPackage::create([
+            'event_id' => $event->id,
+            'package_id' => $package->id,
+            'purchased_price' => $package->price,
+            'purchased_at' => now(),
+            'used_photos' => 2,
+            'used_guests' => 0,
+            'gallery_expires_at' => now()->addDays(7),
+        ])->fresh(['package']);
+
+        /** @var PackageUsageTracker $tracker */
+        $tracker = app(PackageUsageTracker::class);
+
+        $tracker->recordPhotoUsage($eventPackage, 1, 1);
+
+        EventFacade::assertDispatched(EventPackagePhotoLimitReached::class);
+    }
+
+    public function test_dispatches_guest_threshold_event_when_crossed(): void
+    {
+        EventFacade::fake([
+            EventPackageGuestThresholdReached::class,
+            EventPackageGuestLimitReached::class,
+        ]);
+
+        $tenant = Tenant::factory()->create();
+        $package = Package::factory()->endcustomer()->create([
+            'max_guests' => 10,
+        ]);
+        $event = Event::factory()->for($tenant)->create();
+
+        $eventPackage = EventPackage::create([
+            'event_id' => $event->id,
+            'package_id' => $package->id,
+            'purchased_price' => $package->price,
+            'purchased_at' => now(),
+            'used_photos' => 0,
+            'used_guests' => 8,
+            'gallery_expires_at' => now()->addDays(7),
+        ])->fresh(['package']);
+
+        /** @var PackageUsageTracker $tracker */
+        $tracker = app(PackageUsageTracker::class);
+
+        $tracker->recordGuestUsage($eventPackage, 7, 1);
+
+        EventFacade::assertDispatched(EventPackageGuestThresholdReached::class);
+        EventFacade::assertNotDispatched(EventPackageGuestLimitReached::class);
+    }
+
+    public function test_dispatches_guest_limit_event_when_reached(): void
+    {
+        EventFacade::fake([
+            EventPackageGuestThresholdReached::class,
+            EventPackageGuestLimitReached::class,
+        ]);
+
+        $tenant = Tenant::factory()->create();
+        $package = Package::factory()->endcustomer()->create([
+            'max_guests' => 2,
+        ]);
+        $event = Event::factory()->for($tenant)->create();
+
+        $eventPackage = EventPackage::create([
+            'event_id' => $event->id,
+            'package_id' => $package->id,
+            'purchased_price' => $package->price,
+            'purchased_at' => now(),
+            'used_photos' => 0,
+            'used_guests' => 2,
+            'gallery_expires_at' => now()->addDays(7),
+        ])->fresh(['package']);
+
+        /** @var PackageUsageTracker $tracker */
+        $tracker = app(PackageUsageTracker::class);
+
+        $tracker->recordGuestUsage($eventPackage, 1, 1);
+
+        EventFacade::assertDispatched(EventPackageGuestLimitReached::class);
+    }
+}

tests/Unit/Services/TenantUsageTrackerTest.php

@@ -0,0 +1,115 @@
+<?php
+
+namespace Tests\Unit\Services;
+
+use App\Events\Packages\TenantCreditsLow;
+use App\Events\Packages\TenantPackageEventLimitReached;
+use App\Events\Packages\TenantPackageEventThresholdReached;
+use App\Models\Package;
+use App\Models\Tenant;
+use App\Models\TenantPackage;
+use App\Services\Packages\TenantUsageTracker;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\Config;
+use Illuminate\Support\Facades\Event as EventFacade;
+use Tests\TestCase;
+
+class TenantUsageTrackerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_record_event_usage_dispatches_threshold_and_updates_columns(): void
+    {
+        EventFacade::fake([
+            TenantPackageEventThresholdReached::class,
+            TenantPackageEventLimitReached::class,
+        ]);
+
+        Config::set('package-limits.event_thresholds', [0.5]);
+
+        $tenant = Tenant::factory()->create();
+        $package = Package::factory()->reseller()->create([
+            'max_events_per_year' => 10,
+        ]);
+
+        $tenantPackage = TenantPackage::factory()
+            ->for($tenant)
+            ->for($package)
+            ->create([
+                'used_events' => 6,
+            ])->fresh();
+
+        /** @var TenantUsageTracker $tracker */
+        $tracker = app(TenantUsageTracker::class);
+
+        $tracker->recordEventUsage($tenantPackage, 4, 2);
+
+        EventFacade::assertDispatched(TenantPackageEventThresholdReached::class);
+        EventFacade::assertNotDispatched(TenantPackageEventLimitReached::class);
+
+        $tenantPackage->refresh();
+
+        $this->assertNotNull($tenantPackage->event_warning_sent_at);
+        $this->assertSame(0.5, (float) $tenantPackage->event_warning_threshold);
+    }
+
+    public function test_record_event_usage_dispatches_limit_and_sets_timestamp(): void
+    {
+        EventFacade::fake([
+            TenantPackageEventThresholdReached::class,
+            TenantPackageEventLimitReached::class,
+        ]);
+
+        Config::set('package-limits.event_thresholds', [0.5]);
+
+        $tenant = Tenant::factory()->create();
+        $package = Package::factory()->reseller()->create([
+            'max_events_per_year' => 3,
+        ]);
+
+        $tenantPackage = TenantPackage::factory()
+            ->for($tenant)
+            ->for($package)
+            ->create([
+                'used_events' => 3,
+            ])->fresh();
+
+        /** @var TenantUsageTracker $tracker */
+        $tracker = app(TenantUsageTracker::class);
+
+        $tracker->recordEventUsage($tenantPackage, 2, 1);
+
+        EventFacade::assertDispatched(TenantPackageEventLimitReached::class);
+
+        $tenantPackage->refresh();
+
+        $this->assertNotNull($tenantPackage->event_limit_notified_at);
+    }
+
+    public function test_record_credit_balance_dispatches_event_and_updates_tenant(): void
+    {
+        EventFacade::fake([TenantCreditsLow::class]);
+
+        Config::set('package-limits.credit_thresholds', [5, 1]);
+
+        $tenant = Tenant::factory()->create([
+            'event_credits_balance' => 5,
+            'credit_warning_sent_at' => null,
+            'credit_warning_threshold' => null,
+        ]);
+
+        /** @var TenantUsageTracker $tracker */
+        $tracker = app(TenantUsageTracker::class);
+
+        $tracker->recordCreditBalance($tenant, 6, 5);
+
+        EventFacade::assertDispatched(TenantCreditsLow::class, function ($event) use ($tenant) {
+            return $event->tenant->is($tenant) && $event->threshold === 5;
+        });
+
+        $tenant->refresh();
+
+        $this->assertNotNull($tenant->credit_warning_sent_at);
+        $this->assertSame(5, $tenant->credit_warning_threshold);
+    }
+}

tests/Unit/TenantModelTest.php

@@ -2,6 +2,8 @@
 
 namespace Tests\Unit;
 
+use App\Events\Packages\TenantPackageEventLimitReached;
+use App\Events\Packages\TenantPackageEventThresholdReached;
 use App\Models\Event;
 use App\Models\Package;
 use App\Models\PackagePurchase;
@@ -9,13 +11,15 @@ use App\Models\Photo;
 use App\Models\Tenant;
 use App\Models\TenantPackage;
 use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\Config;
+use Illuminate\Support\Facades\Event as EventFacade;
 use Tests\TestCase;
 
 class TenantModelTest extends TestCase
 {
     use RefreshDatabase;
 
-    public function testTenantHasManyEvents(): void
+    public function test_tenant_has_many_events(): void
     {
         $tenant = Tenant::factory()->create();
         Event::factory()->count(3)->create(['tenant_id' => $tenant->id]);
@@ -23,7 +27,7 @@ class TenantModelTest extends TestCase
         $this->assertCount(3, $tenant->events()->get());
     }
 
-    public function testTenantHasPhotosThroughEvents(): void
+    public function test_tenant_has_photos_through_events(): void
     {
         $tenant = Tenant::factory()->create();
         $event = Event::factory()->create(['tenant_id' => $tenant->id]);
@@ -32,7 +36,7 @@ class TenantModelTest extends TestCase
         $this->assertCount(2, $tenant->photos()->get());
     }
 
-    public function testTenantHasManyPackagePurchases(): void
+    public function test_tenant_has_many_package_purchases(): void
     {
         $tenant = Tenant::factory()->create();
         $package = Package::factory()->create();
@@ -44,7 +48,7 @@ class TenantModelTest extends TestCase
         $this->assertCount(2, $tenant->purchases()->get());
     }
 
-    public function testActiveSubscriptionAccessorReturnsTrueWhenActivePackageExists(): void
+    public function test_active_subscription_accessor_returns_true_when_active_package_exists(): void
     {
         $tenant = Tenant::factory()->create();
         $package = Package::factory()->create(['type' => 'reseller']);
@@ -58,21 +62,21 @@ class TenantModelTest extends TestCase
         $this->assertTrue($tenant->fresh()->active_subscription);
     }
 
-    public function testActiveSubscriptionAccessorReturnsFalseWithoutActivePackage(): void
+    public function test_active_subscription_accessor_returns_false_without_active_package(): void
     {
         $tenant = Tenant::factory()->create();
 
         $this->assertFalse($tenant->fresh()->active_subscription);
     }
 
-    public function testIncrementUsedEventsReturnsFalseWithoutActivePackage(): void
+    public function test_increment_used_events_returns_false_without_active_package(): void
     {
         $tenant = Tenant::factory()->create();
 
         $this->assertFalse($tenant->incrementUsedEvents());
     }
 
-    public function testIncrementUsedEventsUpdatesActivePackage(): void
+    public function test_increment_used_events_updates_active_package(): void
     {
         $tenant = Tenant::factory()->create();
         $package = Package::factory()->create(['type' => 'reseller']);
@@ -87,7 +91,41 @@ class TenantModelTest extends TestCase
         $this->assertEquals(3, $tenantPackage->fresh()->used_events);
     }
 
-    public function testSettingsCastToArray(): void
+    public function test_consume_event_allowance_dispatches_notifications_and_updates_usage(): void
+    {
+        EventFacade::fake([
+            TenantPackageEventThresholdReached::class,
+            TenantPackageEventLimitReached::class,
+        ]);
+
+        Config::set('package-limits.event_thresholds', [0.5]);
+
+        $tenant = Tenant::factory()->create();
+        $package = Package::factory()->create([
+            'type' => 'reseller',
+            'max_events_per_year' => 4,
+        ]);
+
+        $tenantPackage = TenantPackage::factory()->create([
+            'tenant_id' => $tenant->id,
+            'package_id' => $package->id,
+            'active' => true,
+            'used_events' => 1,
+        ]);
+
+        $this->assertTrue($tenant->consumeEventAllowance());
+
+        EventFacade::assertDispatched(TenantPackageEventThresholdReached::class);
+        EventFacade::assertNotDispatched(TenantPackageEventLimitReached::class);
+
+        $tenantPackage->refresh();
+
+        $this->assertSame(2, $tenantPackage->used_events);
+        $this->assertNotNull($tenantPackage->event_warning_sent_at);
+        $this->assertSame(0.5, (float) $tenantPackage->event_warning_threshold);
+    }
+
+    public function test_settings_cast_to_array(): void
     {
         $tenant = Tenant::factory()->create([
             'settings' => ['theme' => 'dark', 'logo' => 'logo.png'],
@@ -97,7 +135,7 @@ class TenantModelTest extends TestCase
         $this->assertSame('dark', $tenant->settings['theme']);
     }
 
-    public function testFeaturesCastToArray(): void
+    public function test_features_cast_to_array(): void
     {
         $tenant = Tenant::factory()->create([
             'features' => ['photo_likes' => true, 'analytics' => false],
@@ -107,4 +145,23 @@ class TenantModelTest extends TestCase
         $this->assertTrue($tenant->features['photo_likes']);
         $this->assertFalse($tenant->features['analytics']);
     }
+
+    public function test_increment_credits_clears_warning_when_balance_above_threshold(): void
+    {
+        Config::set('package-limits.credit_thresholds', [5, 1]);
+
+        $tenant = Tenant::factory()->create([
+            'event_credits_balance' => 1,
+            'credit_warning_sent_at' => now()->subDay(),
+            'credit_warning_threshold' => 1,
+        ]);
+
+        $tenant->incrementCredits(10);
+
+        $tenant->refresh();
+
+        $this->assertNull($tenant->credit_warning_sent_at);
+        $this->assertNull($tenant->credit_warning_threshold);
+        $this->assertSame(11, (int) $tenant->event_credits_balance);
+    }
 }