strprfcrm/tests/Feature/MafOrderControllerTest.php

<?php

namespace Tests\Feature;

use App\Models\MafOrder;
use App\Models\Product;
use App\Models\Role;
use App\Models\User;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;

class MafOrderControllerTest extends TestCase
{
    use RefreshDatabase;

    protected $seed = true;

    private User $adminUser;
    private User $managerUser;
    private User $assistantHeadUser;

    protected function setUp(): void
    {
        parent::setUp();

        $this->adminUser = User::factory()->create(['role' => Role::ADMIN]);
        $this->managerUser = User::factory()->create(['role' => Role::MANAGER]);
        $this->assistantHeadUser = User::factory()->create(['role' => Role::ASSISTANT_HEAD]);
    }

    private function assertRedirectsToMafShowWithGeneratedNav($response, MafOrder $mafOrder): void
    {
        $location = $response->headers->get('Location');

        $this->assertNotNull($location);
        $this->assertStringStartsWith(route('maf_order.show', $mafOrder), $location);
        $this->assertStringContainsString('nav=', $location);
    }

    // ==================== Authentication ====================

    public function test_guest_cannot_access_maf_orders_index(): void
    {
        $response = $this->get(route('maf_order.index'));

        $response->assertRedirect(route('login'));
    }

    public function test_authenticated_admin_can_access_maf_orders_index(): void
    {
        $response = $this->actingAs($this->adminUser)
            ->get(route('maf_order.index'));

        $response->assertStatus(200);
        $response->assertViewIs('maf_orders.index');
    }

    public function test_manager_cannot_access_maf_orders_index(): void
    {
        $response = $this->actingAs($this->managerUser)
            ->get(route('maf_order.index'));

        $response->assertStatus(403);
    }

    public function test_assistant_head_can_access_maf_orders_index(): void
    {
        $response = $this->actingAs($this->assistantHeadUser)
            ->get(route('maf_order.index'));

        $response->assertStatus(200);
        $response->assertViewIs('maf_orders.index');
    }

    // ==================== Index ====================

    public function test_maf_orders_index_displays_orders(): void
    {
        MafOrder::factory()->create();

        $response = $this->actingAs($this->adminUser)
            ->get(route('maf_order.index'));

        $response->assertStatus(200);
    }

    // ==================== Store (create) ====================

    public function test_can_create_maf_order(): void
    {
        $product = Product::factory()->create();

        $response = $this->actingAs($this->adminUser)
            ->post(route('maf_order.store'), [
                'product_id' => $product->id,
                'quantity'   => 5,
                'order_number' => 'MO-TEST-001',
            ]);

        $response->assertRedirect();
        $this->assertDatabaseHas('maf_orders', [
            'product_id'   => $product->id,
            'quantity'     => 5,
            'order_number' => 'MO-TEST-001',
            'in_stock'     => 0,
        ]);
    }

    public function test_store_maf_order_requires_product_id(): void
    {
        $response = $this->actingAs($this->adminUser)
            ->post(route('maf_order.store'), [
                'quantity' => 5,
            ]);

        $response->assertSessionHasErrors('product_id');
    }

    public function test_store_maf_order_requires_quantity(): void
    {
        $product = Product::factory()->create();

        $response = $this->actingAs($this->adminUser)
            ->post(route('maf_order.store'), [
                'product_id' => $product->id,
            ]);

        $response->assertSessionHasErrors('quantity');
    }

    public function test_guest_cannot_create_maf_order(): void
    {
        $product = Product::factory()->create();

        $response = $this->post(route('maf_order.store'), [
            'product_id' => $product->id,
            'quantity'   => 3,
        ]);

        $response->assertRedirect(route('login'));
    }

    // ==================== Show ====================

    public function test_can_view_maf_order_details(): void
    {
        $mafOrder = MafOrder::factory()->create();

        $response = $this->actingAs($this->adminUser)
            ->get(route('maf_order.show', $mafOrder));

        $response->assertStatus(200);
        $response->assertViewIs('maf_orders.edit');
    }

    public function test_maf_order_show_uses_nav_context_back_url(): void
    {
        $mafOrder = MafOrder::factory()->create();

        $indexResponse = $this->actingAs($this->adminUser)
            ->get(route('maf_order.index', [
                'filters' => ['user_name' => $this->adminUser->name],
            ]));

        $nav = $indexResponse->viewData('nav');

        $response = $this->actingAs($this->adminUser)
            ->get(route('maf_order.show', [
                'maf_order' => $mafOrder,
                'nav' => $nav,
            ]));

        $response->assertOk();
        $response->assertViewHas('nav', $nav);
        $response->assertViewHas('back_url', function (string $backUrl): bool {
            if (!str_starts_with($backUrl, route('maf_order.index'))) {
                return false;
            }

            $query = parse_url($backUrl, PHP_URL_QUERY);
            parse_str((string) $query, $params);

            return ($params['filters']['user_name'] ?? null) === $this->adminUser->name;
        });
    }

    public function test_guest_cannot_view_maf_order_details(): void
    {
        $mafOrder = MafOrder::factory()->create();

        $response = $this->get(route('maf_order.show', $mafOrder));

        $response->assertRedirect(route('login'));
    }

    // ==================== Update ====================

    public function test_can_update_maf_order(): void
    {
        $product = Product::factory()->create();
        $mafOrder = MafOrder::factory()->create([
            'product_id' => $product->id,
            'quantity'   => 3,
        ]);

        $response = $this->actingAs($this->adminUser)
            ->post(route('maf_order.update', $mafOrder), [
                'product_id'   => $product->id,
                'quantity'     => 10,
                'order_number' => 'MO-UPDATED',
            ]);

        $response->assertRedirect();
        $this->assertDatabaseHas('maf_orders', [
            'id'       => $mafOrder->id,
            'quantity' => 10,
        ]);
    }

    public function test_guest_cannot_update_maf_order(): void
    {
        $product = Product::factory()->create();
        $mafOrder = MafOrder::factory()->create(['product_id' => $product->id]);

        $response = $this->post(route('maf_order.update', $mafOrder), [
            'product_id' => $product->id,
            'quantity'   => 10,
        ]);

        $response->assertRedirect(route('login'));
    }

    // ==================== Destroy ====================

    public function test_can_delete_maf_order(): void
    {
        $mafOrder = MafOrder::factory()->create();
        $mafOrderId = $mafOrder->id;

        $response = $this->actingAs($this->adminUser)
            ->delete(route('maf_order.delete', $mafOrder));

        $response->assertRedirect();
        $this->assertSoftDeleted('maf_orders', ['id' => $mafOrderId]);
    }

    public function test_guest_cannot_delete_maf_order(): void
    {
        $mafOrder = MafOrder::factory()->create();

        $response = $this->delete(route('maf_order.delete', $mafOrder));

        $response->assertRedirect(route('login'));
    }

    // ==================== SetInStock ====================

    public function test_set_in_stock_updates_stock_and_status(): void
    {
        $mafOrder = MafOrder::factory()->create([
            'quantity' => 8,
            'in_stock' => 0,
            'status'   => 'active',
        ]);

        $response = $this->actingAs($this->adminUser)
            ->post(route('maf_order.set_in_stock', $mafOrder));

        $this->assertRedirectsToMafShowWithGeneratedNav($response, $mafOrder);
        $this->assertDatabaseHas('maf_orders', [
            'id'       => $mafOrder->id,
            'in_stock' => 8,
            'status'   => 'на складе',
        ]);
    }

    public function test_guest_cannot_set_in_stock(): void
    {
        $mafOrder = MafOrder::factory()->create(['quantity' => 5]);

        $response = $this->post(route('maf_order.set_in_stock', $mafOrder));

        $response->assertRedirect(route('login'));
    }

    public function test_set_order_in_stock_updates_all_rows_by_order_number(): void
    {
        $first = MafOrder::factory()->create([
            'order_number' => 'MO-BULK-001',
            'quantity' => 3,
            'in_stock' => 0,
            'status' => 'заказан',
        ]);
        $second = MafOrder::factory()->create([
            'order_number' => 'MO-BULK-001',
            'quantity' => 7,
            'in_stock' => 1,
            'status' => 'заказан',
        ]);
        $other = MafOrder::factory()->create([
            'order_number' => 'MO-BULK-002',
            'quantity' => 9,
            'in_stock' => 2,
            'status' => 'заказан',
        ]);

        $response = $this->actingAs($this->adminUser)
            ->post(route('maf_order.set_order_in_stock'), [
                'bulk_order_number' => 'MO-BULK-001',
            ]);

        $response->assertRedirect(route('maf_order.index'));
        $this->assertDatabaseHas('maf_orders', [
            'id' => $first->id,
            'in_stock' => 3,
            'status' => 'на складе',
        ]);
        $this->assertDatabaseHas('maf_orders', [
            'id' => $second->id,
            'in_stock' => 7,
            'status' => 'на складе',
        ]);
        $this->assertDatabaseHas('maf_orders', [
            'id' => $other->id,
            'in_stock' => 2,
            'status' => 'заказан',
        ]);
    }

    public function test_guest_cannot_set_order_in_stock(): void
    {
        $response = $this->post(route('maf_order.set_order_in_stock'), [
            'bulk_order_number' => 'MO-BULK-001',
        ]);

        $response->assertRedirect(route('login'));
    }
}