strprfcrm/tests/Unit/Models/ReclamationTest.php

<?php

namespace Tests\Unit\Models;

use App\Models\Order;
use App\Models\Reclamation;
use App\Models\ReclamationType;
use App\Models\Reservation;
use App\Models\Shortage;
use App\Models\SparePart;
use App\Models\SparePartOrder;
use App\Models\User;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;
use Database\Seeders\ReclamationTypeSeeder;

class ReclamationTest extends TestCase
{
    use RefreshDatabase;

    protected $seed = true;

    // ==================== Status Constants ====================

    public function test_status_constants_are_defined(): void
    {
        $this->assertEquals(1, Reclamation::STATUS_NEW);
        $this->assertEquals(2, Reclamation::STATUS_WAIT);
        $this->assertEquals(3, Reclamation::STATUS_IN_WORK);
        $this->assertEquals(4, Reclamation::STATUS_SUBSCRIBE_ACT);
        $this->assertEquals(5, Reclamation::STATUS_DONE);
        $this->assertEquals(6, Reclamation::STATUS_SENT);
        $this->assertEquals(7, Reclamation::STATUS_DO_DOCS);
        $this->assertEquals(8, Reclamation::STATUS_HANDOVER_TO_CHECK);
        $this->assertEquals(9, Reclamation::STATUS_PAID);
        $this->assertEquals(10, Reclamation::STATUS_CLOSED_NO_PAY);
    }

    public function test_status_names_are_defined(): void
    {
        $this->assertArrayHasKey(Reclamation::STATUS_NEW, Reclamation::STATUS_NAMES);
        $this->assertEquals('Новая', Reclamation::STATUS_NAMES[Reclamation::STATUS_NEW]);
        $this->assertEquals('Оплачена', Reclamation::STATUS_NAMES[Reclamation::STATUS_PAID]);
    }

    // ==================== Relationships ====================

    public function test_reclamation_belongs_to_order(): void
    {
        // Arrange
        $reclamation = Reclamation::factory()->create();

        // Act & Assert
        $this->assertInstanceOf(Order::class, $reclamation->order);
    }

    public function test_reclamation_belongs_to_user(): void
    {
        // Arrange
        $user = User::factory()->create();
        $reclamation = Reclamation::factory()->create(['user_id' => $user->id]);

        // Act & Assert
        $this->assertInstanceOf(User::class, $reclamation->user);
        $this->assertEquals($user->id, $reclamation->user->id);
    }

    public function test_reclamation_belongs_to_brigadier(): void
    {
        // Arrange
        $brigadier = User::factory()->create();
        $reclamation = Reclamation::factory()->create(['brigadier_id' => $brigadier->id]);

        // Act & Assert
        $this->assertInstanceOf(User::class, $reclamation->brigadier);
        $this->assertEquals($brigadier->id, $reclamation->brigadier->id);
    }

    public function test_reclamation_belongs_to_type(): void
    {
        $reclamation = Reclamation::factory()->create();

        $this->assertInstanceOf(ReclamationType::class, $reclamation->reclamationType);
        $this->assertTrue($reclamation->isDkr());
    }

    public function test_other_reclamation_is_not_dkr(): void
    {
        $reclamation = Reclamation::factory()->other()->create();

        $this->assertSame(ReclamationType::CODE_OTHER, $reclamation->reclamationType->code);
        $this->assertFalse($reclamation->isDkr());
    }

    public function test_reclamation_type_seeder_is_idempotent(): void
    {
        $this->seed(ReclamationTypeSeeder::class);
        $this->seed(ReclamationTypeSeeder::class);

        $this->assertDatabaseCount('reclamation_types', 2);
        $this->assertDatabaseHas('reclamation_types', [
            'code' => ReclamationType::CODE_DKR,
            'name' => 'ДКР',
        ]);
        $this->assertDatabaseHas('reclamation_types', [
            'code' => ReclamationType::CODE_OTHER,
            'name' => 'Прочее',
        ]);
    }

    public function test_reclamation_has_many_spare_part_reservations(): void
    {
        // Arrange
        $reclamation = Reclamation::factory()->create();
        $sparePart = SparePart::factory()->create();
        $order = SparePartOrder::factory()
            ->inStock()
            ->forSparePart($sparePart)
            ->create();

        Reservation::factory()
            ->active()
            ->fromOrder($order)
            ->forReclamation($reclamation)
            ->count(3)
            ->create();

        // Act
        $reservations = $reclamation->sparePartReservations;

        // Assert
        $this->assertCount(3, $reservations);
        $this->assertInstanceOf(Reservation::class, $reservations->first());
    }

    public function test_reclamation_has_many_spare_part_shortages(): void
    {
        // Arrange
        $reclamation = Reclamation::factory()->create();
        $sparePart = SparePart::factory()->create();

        Shortage::factory()
            ->open()
            ->forSparePart($sparePart)
            ->forReclamation($reclamation)
            ->count(2)
            ->create();

        // Act
        $shortages = $reclamation->sparePartShortages;

        // Assert
        $this->assertCount(2, $shortages);
        $this->assertInstanceOf(Shortage::class, $shortages->first());
    }

    // ==================== Active Reservations ====================

    public function test_active_reservations_returns_only_active_status(): void
    {
        // Arrange
        $reclamation = Reclamation::factory()->create();
        $sparePart = SparePart::factory()->create();
        $order = SparePartOrder::factory()
            ->inStock()
            ->forSparePart($sparePart)
            ->create();

        Reservation::factory()
            ->active()
            ->fromOrder($order)
            ->forReclamation($reclamation)
            ->count(2)
            ->create();

        Reservation::factory()
            ->cancelled()
            ->fromOrder($order)
            ->forReclamation($reclamation)
            ->create();

        Reservation::factory()
            ->issued()
            ->fromOrder($order)
            ->forReclamation($reclamation)
            ->create();

        // Act
        $activeReservations = $reclamation->activeReservations;

        // Assert
        $this->assertCount(2, $activeReservations);
        $activeReservations->each(function ($reservation) {
            $this->assertEquals(Reservation::STATUS_ACTIVE, $reservation->status);
        });
    }

    // ==================== Open Shortages ====================

    public function test_open_shortages_returns_only_open_status(): void
    {
        // Arrange
        $reclamation = Reclamation::factory()->create();
        $sparePart = SparePart::factory()->create();

        Shortage::factory()
            ->open()
            ->forSparePart($sparePart)
            ->forReclamation($reclamation)
            ->count(2)
            ->create();

        Shortage::factory()
            ->closed()
            ->forSparePart($sparePart)
            ->forReclamation($reclamation)
            ->create();

        // Act
        $openShortages = $reclamation->openShortages;

        // Assert
        $this->assertCount(2, $openShortages);
        $openShortages->each(function ($shortage) {
            $this->assertEquals(Shortage::STATUS_OPEN, $shortage->status);
        });
    }

    // ==================== Factory ====================

    public function test_factory_creates_valid_reclamation(): void
    {
        // Act
        $reclamation = Reclamation::factory()->create();

        // Assert
        $this->assertDatabaseHas('reclamations', [
            'id' => $reclamation->id,
        ]);
        $this->assertNotNull($reclamation->order_id);
        $this->assertNotNull($reclamation->user_id);
    }
}