strprfcrm/tests/Unit/Models/OrderTest.php

<?php

namespace Tests\Unit\Models;

use App\Models\Dictionary\Area;
use App\Models\Dictionary\District;
use App\Models\File;
use App\Models\MafOrder;
use App\Models\ObjectType;
use App\Models\Order;
use App\Models\Product;
use App\Models\ProductSKU;
use App\Models\Reclamation;
use App\Models\User;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;

class OrderTest extends TestCase
{
    use RefreshDatabase;

    protected $seed = true;

    public function test_status_constants_exist(): void
    {
        $this->assertEquals(1, Order::STATUS_NEW);
        $this->assertEquals(2, Order::STATUS_NOT_READY);
        $this->assertEquals(3, Order::STATUS_READY_NO_MAF);
        $this->assertEquals(4, Order::STATUS_READY_TO_MOUNT);
        $this->assertEquals(5, Order::STATUS_IN_MOUNT);
        $this->assertEquals(6, Order::STATUS_DUTY);
        $this->assertEquals(7, Order::STATUS_READY_TO_HAND_OVER);
        $this->assertEquals(8, Order::STATUS_NOT_HANDED_OVER_WITH_NOTES);
        $this->assertEquals(9, Order::STATUS_HANDED_OVER_WITH_NOTES);
        $this->assertEquals(10, Order::STATUS_HANDED_OVER);
        $this->assertEquals(11, Order::STATUS_NO_MAF);
        $this->assertEquals(12, Order::STATUS_PROBLEM);
    }

    public function test_status_names_array_contains_all_statuses(): void
    {
        $this->assertArrayHasKey(Order::STATUS_NEW, Order::STATUS_NAMES);
        $this->assertArrayHasKey(Order::STATUS_HANDED_OVER, Order::STATUS_NAMES);
        $this->assertArrayHasKey(Order::STATUS_PROBLEM, Order::STATUS_NAMES);

        $this->assertEquals('Новая', Order::STATUS_NAMES[Order::STATUS_NEW]);
        $this->assertEquals('Сдана', Order::STATUS_NAMES[Order::STATUS_HANDED_OVER]);
    }

    public function test_status_colors_array_exists(): void
    {
        $this->assertArrayHasKey(Order::STATUS_NEW, Order::STATUS_COLOR);
        $this->assertArrayHasKey(Order::STATUS_HANDED_OVER, Order::STATUS_COLOR);
        $this->assertEquals('success', Order::STATUS_COLOR[Order::STATUS_HANDED_OVER]);
        $this->assertEquals('danger', Order::STATUS_COLOR[Order::STATUS_PROBLEM]);
    }

    public function test_year_defaults_to_current_year_on_create(): void
    {
        $district = District::factory()->create();
        $area = Area::factory()->create(['district_id' => $district->id]);
        $user = User::factory()->create();
        $objectType = ObjectType::first();

        $order = Order::create([
            'name' => 'Test Order',
            'user_id' => $user->id,
            'district_id' => $district->id,
            'area_id' => $area->id,
            'object_address' => 'Test Address',
            'object_type_id' => $objectType->id,
            'order_status_id' => Order::STATUS_NEW,
        ]);

        $this->assertEquals((int) date('Y'), $order->year);
    }

    public function test_common_name_attribute_combines_address_area_district(): void
    {
        $district = District::factory()->create(['shortname' => 'ЦАО']);
        $area = Area::factory()->create([
            'name' => 'Тверской',
            'district_id' => $district->id,
        ]);

        $order = Order::factory()->create([
            'object_address' => 'ул. Пушкина, д. 10',
            'district_id' => $district->id,
            'area_id' => $area->id,
        ]);

        $this->assertStringContainsString('ул. Пушкина, д. 10', $order->common_name);
        $this->assertStringContainsString('Тверской', $order->common_name);
        $this->assertStringContainsString('ЦАО', $order->common_name);
    }

    public function test_relations_exist(): void
    {
        $order = Order::factory()->create();

        $this->assertInstanceOf(\Illuminate\Database\Eloquent\Relations\BelongsTo::class, $order->user());
        $this->assertInstanceOf(\Illuminate\Database\Eloquent\Relations\BelongsTo::class, $order->district());
        $this->assertInstanceOf(\Illuminate\Database\Eloquent\Relations\BelongsTo::class, $order->area());
        $this->assertInstanceOf(\Illuminate\Database\Eloquent\Relations\BelongsTo::class, $order->brigadier());
        $this->assertInstanceOf(\Illuminate\Database\Eloquent\Relations\HasMany::class, $order->products_sku());
        $this->assertInstanceOf(\Illuminate\Database\Eloquent\Relations\HasMany::class, $order->reclamations());
        $this->assertInstanceOf(\Illuminate\Database\Eloquent\Relations\BelongsToMany::class, $order->photos());
        $this->assertInstanceOf(\Illuminate\Database\Eloquent\Relations\BelongsToMany::class, $order->documents());
    }

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

        ProductSKU::factory()->create([
            'order_id' => $order->id,
            'product_id' => $product->id,
            'maf_order_id' => $mafOrder->id,
        ]);

        $errors = $order->isAllMafConnected();

        $this->assertEmpty($errors);
    }

    public function test_is_all_maf_connected_returns_errors_when_not_connected(): void
    {
        $order = Order::factory()->create();
        $product = Product::factory()->create(['article' => 'TEST-001']);

        ProductSKU::factory()->create([
            'order_id' => $order->id,
            'product_id' => $product->id,
            'maf_order_id' => null, // Not connected
        ]);

        $errors = $order->isAllMafConnected();

        $this->assertNotEmpty($errors);
        $this->assertStringContainsString('TEST-001', $errors[0]);
    }

    public function test_can_create_handover_checks_required_fields(): void
    {
        $order = Order::factory()->create();
        $product = Product::factory()->create([
            'article' => 'TEST-001',
            'passport_name' => null, // Missing
        ]);

        ProductSKU::factory()->create([
            'order_id' => $order->id,
            'product_id' => $product->id,
            'maf_order_id' => null,
            'passport_id' => null,
            'rfid' => null,
        ]);

        $errors = $order->canCreateHandover();

        $this->assertNotEmpty($errors);
        // Should have multiple errors for missing fields
        $this->assertGreaterThan(1, count($errors));
    }

    public function test_can_create_handover_requires_photos(): void
    {
        $order = Order::factory()->create();
        // Order without photos

        $errors = $order->canCreateHandover();

        $this->assertContains('Не загружены фотографии!', $errors);
    }

    public function test_fillable_attributes(): void
    {
        $order = new Order();
        $fillable = $order->getFillable();

        $this->assertContains('year', $fillable);
        $this->assertContains('name', $fillable);
        $this->assertContains('user_id', $fillable);
        $this->assertContains('district_id', $fillable);
        $this->assertContains('area_id', $fillable);
        $this->assertContains('object_address', $fillable);
        $this->assertContains('order_status_id', $fillable);
        $this->assertContains('installation_date', $fillable);
        $this->assertContains('brigadier_id', $fillable);
    }

    public function test_appends_include_required_attributes(): void
    {
        $order = new Order();

        $this->assertContains('common_name', $order->appends);
        $this->assertContains('products_with_count', $order->appends);
    }

    public function test_soft_deletes_trait_is_used(): void
    {
        $order = Order::factory()->create();

        $order->delete();

        $this->assertSoftDeleted($order);
        $this->assertNotNull($order->deleted_at);
    }

    public function test_order_can_have_reclamations(): void
    {
        $order = Order::factory()->create();

        Reclamation::factory()->count(3)->create([
            'order_id' => $order->id,
        ]);

        $this->assertCount(3, $order->reclamations);
    }

    public function test_order_can_have_brigadier(): void
    {
        $brigadier = User::factory()->brigadier()->create();
        $order = Order::factory()->withBrigadier($brigadier)->create();

        $order->refresh();

        $this->assertEquals($brigadier->id, $order->brigadier_id);
        $this->assertEquals($brigadier->id, $order->brigadier->id);
    }
}