strprfcrm/tests/Unit/Services/SparePartReservationServiceMockTest.php

<?php

namespace Tests\Unit\Services;

use App\Models\Reservation;
use App\Models\Shortage;
use App\Services\ReservationResult;
use App\Services\ShortageService;
use App\Services\SparePartReservationService;
use Illuminate\Support\Collection;
use Mockery;
use Tests\TestCase;

/**
 * Unit-тесты SparePartReservationService с Mockery-моками без реальной БД.
 *
 * Тестирует:
 * - Вычислительную логику ReservationResult (не требует БД)
 * - Корректность инстанцирования сервиса с mock ShortageService
 * - cancelReservation() с mock Reservation, где isActive() возвращает false
 */
class SparePartReservationServiceMockTest extends TestCase
{
    protected function tearDown(): void
    {
        Mockery::close();
        parent::tearDown();
    }

    // ==================== ReservationResult: isFullyReserved ====================

    public function test_reservation_result_is_fully_reserved_when_no_missing(): void
    {
        $shortage = Mockery::mock(Shortage::class);

        $result = new ReservationResult(
            reserved: 10,
            missing: 0,
            reservations: collect(),
            shortage: null
        );

        $this->assertTrue($result->isFullyReserved());
        $this->assertEquals(0, $result->missing);
    }

    // ==================== ReservationResult: hasShortage ====================

    public function test_reservation_result_has_shortage_when_missing_exists(): void
    {
        $shortage = Mockery::mock(Shortage::class);

        $result = new ReservationResult(
            reserved: 3,
            missing: 2,
            reservations: collect(),
            shortage: $shortage
        );

        $this->assertFalse($result->isFullyReserved());
        $this->assertTrue($result->hasShortage());
        $this->assertEquals(2, $result->missing);
        $this->assertEquals(3, $result->reserved);
    }

    // ==================== ReservationResult: getTotalRequested ====================

    public function test_reservation_result_get_total_requested_returns_sum(): void
    {
        $result = new ReservationResult(
            reserved: 7,
            missing: 3,
            reservations: collect(),
            shortage: null
        );

        $this->assertEquals(10, $result->getTotalRequested());
    }

    public function test_reservation_result_get_total_requested_when_fully_reserved(): void
    {
        $result = new ReservationResult(
            reserved: 5,
            missing: 0,
            reservations: collect(),
            shortage: null
        );

        $this->assertEquals(5, $result->getTotalRequested());
    }

    public function test_reservation_result_get_total_requested_when_nothing_reserved(): void
    {
        $result = new ReservationResult(
            reserved: 0,
            missing: 8,
            reservations: collect(),
            shortage: null
        );

        $this->assertEquals(8, $result->getTotalRequested());
    }

    // ==================== Service instantiation ====================

    public function test_service_accepts_shortage_service_dependency(): void
    {
        $shortageService = Mockery::mock(ShortageService::class);

        $service = new SparePartReservationService($shortageService);

        $this->assertInstanceOf(SparePartReservationService::class, $service);
    }

    public function test_service_can_be_instantiated_with_real_shortage_service(): void
    {
        $shortageService = new ShortageService();
        $service = new SparePartReservationService($shortageService);

        $this->assertInstanceOf(SparePartReservationService::class, $service);
    }

    // ==================== cancelReservation: non-active reservation ====================

    public function test_cancel_reservation_returns_false_for_non_active(): void
    {
        $shortageService = Mockery::mock(ShortageService::class);
        $service = new SparePartReservationService($shortageService);

        $reservation = Mockery::mock(Reservation::class);
        $reservation->shouldReceive('isActive')->once()->andReturn(false);

        $result = $service->cancelReservation($reservation);

        $this->assertFalse($result);
    }

    // ==================== ReservationResult: reservations collection ====================

    public function test_reservation_result_holds_reservations_collection(): void
    {
        $reservations = collect([
            Mockery::mock(Reservation::class),
            Mockery::mock(Reservation::class),
        ]);

        $result = new ReservationResult(
            reserved: 2,
            missing: 0,
            reservations: $reservations,
            shortage: null
        );

        $this->assertInstanceOf(Collection::class, $result->reservations);
        $this->assertCount(2, $result->reservations);
        $this->assertTrue($result->isFullyReserved());
        $this->assertFalse($result->hasShortage());
    }

    public function test_reservation_result_has_no_shortage_when_shortage_is_null(): void
    {
        $result = new ReservationResult(
            reserved: 5,
            missing: 0,
            reservations: collect(),
            shortage: null
        );

        $this->assertFalse($result->hasShortage());
        $this->assertNull($result->shortage);
    }
}