Skip to content

A free open source IT asset/license management system

7.9 KB
Raw Blame
<?php

namespace Tests\Feature\Assets;

use App\Models\Asset;
use App\Models\Order;
use App\Models\OrderItem;
use App\Models\Supplier;
use App\Models\User;
use Tests\TestCase;

/**
 * AssetObserver::created writes a matching Order + OrderItem for every
 * new asset regardless of how the asset arrived (web form, API, CSV
 * importer). Dedupe semantics match the adjust-quantity flow: a
 * populated order_number shares the Order row with same-tuple assets,
 * a blank one gets its own Order per event.
 */
class AssetObserverOrderTest extends TestCase
{
    public function test_asset_create_with_order_number_writes_matching_order_and_order_item(): void
    {
        $actor = User::factory()->createAssets()->create();
        $supplier = Supplier::factory()->create();

        $asset = Asset::factory()->create([
            'created_by' => $actor->id,
            'company_id' => $actor->company_id,
            'supplier_id' => $supplier->id,
            'order_number' => 'PO-OBS-1',
            'purchase_date' => '2026-04-01',
            'purchase_cost' => 199.99,
        ]);

        $line = OrderItem::where('item_type', Asset::class)
            ->where('item_id', $asset->id)
            ->firstOrFail();

        $this->assertSame(1, (int) $line->qty);
        $this->assertEquals(199.99, (float) $line->price);

        $order = Order::findOrFail($line->order_id);
        $this->assertSame('PO-OBS-1', $order->order_number);
        $this->assertSame($supplier->id, (int) $order->supplier_id);
        $this->assertSame($actor->company_id, $order->company_id);
        $this->assertSame('2026-04-01', $order->purchase_date->toDateString());
    }

    public function test_two_assets_with_same_order_tuple_share_one_order_row(): void
    {
        $actor = User::factory()->createAssets()->create();
        $supplier = Supplier::factory()->create();

        $shared = [
            'created_by' => $actor->id,
            'company_id' => $actor->company_id,
            'supplier_id' => $supplier->id,
            'order_number' => 'PO-OBS-SHARED',
            'purchase_date' => '2026-04-02',
        ];

        $first = Asset::factory()->create($shared + ['purchase_cost' => 100]);
        $second = Asset::factory()->create($shared + ['purchase_cost' => 200]);

        $orders = Order::where('order_number', 'PO-OBS-SHARED')
            ->where('supplier_id', $supplier->id)
            ->where('company_id', $actor->company_id)
            ->get();

        $this->assertCount(1, $orders, 'Same (order_number, supplier, company) tuple must dedupe.');

        $lineIds = OrderItem::where('item_type', Asset::class)
            ->whereIn('item_id', [$first->id, $second->id])
            ->pluck('order_id')
            ->unique()
            ->values();

        $this->assertCount(1, $lineIds);
        $this->assertSame($orders->first()->id, (int) $lineIds->first());
    }

    public function test_blank_order_number_creates_a_distinct_order_per_asset(): void
    {
        $actor = User::factory()->createAssets()->create();
        $supplier = Supplier::factory()->create();
        $ordersBefore = Order::count();

        $shared = [
            'created_by' => $actor->id,
            'company_id' => $actor->company_id,
            'supplier_id' => $supplier->id,
            'order_number' => null,
        ];

        Asset::factory()->create($shared);
        Asset::factory()->create($shared);

        // Blank order_number = distinct transaction, so both assets get
        // their own Order rows even though supplier + company match.
        $this->assertSame($ordersBefore + 2, Order::count());
    }

    public function test_asset_purchase_cost_change_syncs_to_linked_order_item(): void
    {
        // #19564 sync: editing purchase_cost on a saved asset (single
        // edit, bulk edit, importer update, or API) must write through
        // to the linked OrderItem's price so order-side reads don't
        // diverge from the current asset row.
        $supplier = Supplier::factory()->create();

        $asset = Asset::factory()->create([
            'supplier_id' => $supplier->id,
            'order_number' => 'PO-EDIT-COST',
            'purchase_cost' => 100.00,
        ]);

        $asset->purchase_cost = 175.50;
        $asset->save();

        $line = OrderItem::where('item_type', Asset::class)
            ->where('item_id', $asset->id)
            ->firstOrFail();

        $this->assertEquals(175.50, (float) $line->price);
    }

    public function test_asset_order_number_change_repoints_line_and_cleans_up_orphan(): void
    {
        // Rename an asset's order_number. The asset's OrderItem must
        // detach from the old Order, attach to a firstOrNew'd Order
        // matching the new (order_number, supplier_id, company_id)
        // tuple, and the old Order must be deleted when it's left
        // with no other OrderItems.
        $supplier = Supplier::factory()->create();

        $asset = Asset::factory()->create([
            'supplier_id' => $supplier->id,
            'order_number' => 'PO-OLD',
        ]);

        $oldOrderId = OrderItem::where('item_type', Asset::class)
            ->where('item_id', $asset->id)
            ->value('order_id');

        $this->assertNotNull(Order::find($oldOrderId));

        $asset->order_number = 'PO-NEW';
        $asset->save();

        $line = OrderItem::where('item_type', Asset::class)
            ->where('item_id', $asset->id)
            ->firstOrFail();

        $newOrder = Order::find($line->order_id);

        $this->assertSame('PO-NEW', $newOrder->order_number);
        $this->assertNotSame($oldOrderId, $line->order_id);
        $this->assertNull(Order::find($oldOrderId), 'The old Order should be deleted after the only OrderItem moves away.');
    }

    public function test_asset_order_number_change_preserves_old_order_when_it_has_siblings(): void
    {
        // Two assets share PO-SHARED. Rename asset A to PO-NEW. Old
        // Order (PO-SHARED) must survive because asset B still points
        // at it.
        $supplier = Supplier::factory()->create();

        $assetA = Asset::factory()->create([
            'supplier_id' => $supplier->id,
            'order_number' => 'PO-SHARED',
        ]);
        $assetB = Asset::factory()->create([
            'supplier_id' => $supplier->id,
            'company_id' => $assetA->company_id,
            'order_number' => 'PO-SHARED',
        ]);

        $sharedOrderId = OrderItem::where('item_type', Asset::class)
            ->where('item_id', $assetA->id)
            ->value('order_id');

        $this->assertSame(
            $sharedOrderId,
            OrderItem::where('item_type', Asset::class)->where('item_id', $assetB->id)->value('order_id'),
            'Precondition: both assets share the same Order.',
        );

        $assetA->order_number = 'PO-NEW';
        $assetA->save();

        $this->assertNotNull(Order::find($sharedOrderId), 'The old Order must survive because asset B still references it.');
    }

    public function test_unrelated_save_does_not_touch_the_linked_order_item(): void
    {
        // Sanity: touching a field other than purchase_cost /
        // order_number leaves the OrderItem's price and order_id
        // completely untouched.
        $supplier = Supplier::factory()->create();

        $asset = Asset::factory()->create([
            'supplier_id' => $supplier->id,
            'order_number' => 'PO-NOTES',
            'purchase_cost' => 42.00,
        ]);

        $originalLine = OrderItem::where('item_type', Asset::class)
            ->where('item_id', $asset->id)
            ->firstOrFail();

        $asset->notes = 'edited notes';
        $asset->save();

        $freshLine = OrderItem::where('item_type', Asset::class)
            ->where('item_id', $asset->id)
            ->firstOrFail();

        $this->assertSame($originalLine->id, $freshLine->id);
        $this->assertSame($originalLine->order_id, $freshLine->order_id);
        $this->assertEquals((float) $originalLine->price, (float) $freshLine->price);
    }
}