@fleetbase/fleetops-engine 0.6.58 → 0.6.59

package/server/tests/Unit/Models/EntityTest.php

@@ -0,0 +1,171 @@
+<?php
+
+if (!function_exists('Fleetbase\Traits\config')) {
+    eval('namespace Fleetbase\Traits; function config($key = null, $default = null) { return $key === "api.cache.enabled" ? false : $default; }');
+}
+
+if (!function_exists('Fleetbase\Models\config')) {
+    eval('namespace Fleetbase\Models; function config($key = null, $default = null) { return $key === "fleetbase.connection.db" ? "mysql" : $default; }');
+}
+
+use Fleetbase\FleetOps\Models\Entity;
+use Fleetbase\FleetOps\Models\Payload;
+use Fleetbase\FleetOps\Models\Place;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+class FleetOpsEntityUnitDestinationFake extends Entity
+{
+    public bool $savedForTest = false;
+
+    public function save(array $options = []): bool
+    {
+        $this->savedForTest = true;
+
+        return true;
+    }
+}
+
+class FleetOpsEntityUnitDatabaseProbe
+{
+    public function __construct(private SQLiteConnection $connection)
+    {
+    }
+
+    public function connection(): SQLiteConnection
+    {
+        return $this->connection;
+    }
+}
+
+function fleetopsEntityUnitUseConnection(): void
+{
+    $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
+    $connection->statement('create table entities (uuid varchar(64) primary key, public_id varchar(64) null, internal_id varchar(64) null, _key varchar(64) null, company_uuid varchar(64) null, payload_uuid varchar(64) null, driver_assigned_uuid varchar(64) null, customer_uuid varchar(64) null, customer_type varchar(255) null, tracking_number_uuid varchar(64) null, destination_uuid varchar(64) null, supplier_uuid varchar(64) null, photo_uuid varchar(64) null, _import_id varchar(64) null, name varchar(255) null, type varchar(64) null, description text null, currency varchar(8) null, barcode text null, qr_code text null, weight decimal(12,2) null, weight_unit varchar(16) null, length decimal(12,2) null, width decimal(12,2) null, height decimal(12,2) null, dimensions_unit varchar(16) null, declared_value integer null, sku varchar(255) null, price integer null, sale_price integer null, meta text null, slug varchar(255) null, deleted_at datetime null, created_at datetime null, updated_at datetime null)');
+
+    $resolver = new ConnectionResolver([
+        'default' => $connection,
+        'mysql'   => $connection,
+    ]);
+
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+    app()->instance('db', new FleetOpsEntityUnitDatabaseProbe($connection));
+    Illuminate\Support\Facades\DB::clearResolvedInstance('db');
+    $connection->statement('create table if not exists places (id integer primary key autoincrement, uuid varchar(64) null, public_id varchar(64) null, company_uuid varchar(64) null, name varchar(255) null, meta text null, deleted_at datetime null, created_at datetime null, updated_at datetime null)');
+    app()->instance('responsecache', new class {
+        public function __call($method, $arguments)
+        {
+            return null;
+        }
+    });
+    app()->instance('geocoder', new class {
+        public function geocode($query)
+        {
+            return $this;
+        }
+
+        public function reverse($lat, $lng)
+        {
+            return $this;
+        }
+
+        public function get()
+        {
+            return collect();
+        }
+
+        public function __call($method, $arguments)
+        {
+            return $this;
+        }
+    });
+}
+
+function fleetopsEntityUnitPlace(string $uuid, string $publicId): Place
+{
+    $place = new Place();
+    $place->setRawAttributes([
+        'uuid'      => $uuid,
+        'public_id' => $publicId,
+    ], true);
+
+    return $place;
+}
+
+test('entity destination resolution covers payload and entity fallback branches with optional save', function () {
+    $pickup   = fleetopsEntityUnitPlace('11111111-1111-4111-8111-111111111111', 'place_pickup');
+    $dropoff  = fleetopsEntityUnitPlace('22222222-2222-4222-8222-222222222222', 'place_dropoff');
+    $waypoint = fleetopsEntityUnitPlace('33333333-3333-4333-8333-333333333333', 'place_waypoint');
+
+    $payload = new Payload();
+    $payload->setRelation('pickup', $pickup);
+    $payload->setRelation('dropoff', $dropoff);
+    $payload->setRelation('waypoints', collect([$waypoint]));
+
+    $entitySaved = new FleetOpsEntityUnitDestinationFake();
+
+    expect((new Entity())->setDestination(0, $payload, false)->destination_uuid)->toBe('33333333-3333-4333-8333-333333333333')
+        ->and((new Entity())->setDestination('pickup', $payload, false)->destination_uuid)->toBe('11111111-1111-4111-8111-111111111111')
+        ->and((new Entity())->setDestination('dropoff', $payload, false)->destination_uuid)->toBe('22222222-2222-4222-8222-222222222222')
+        ->and((new Entity())->setDestination('place_waypoint', $payload, false)->destination_uuid)->toBe('33333333-3333-4333-8333-333333333333')
+        ->and((new Entity())->setDestination('22222222-2222-4222-8222-222222222222', $payload, false)->destination_uuid)->toBe('22222222-2222-4222-8222-222222222222')
+        ->and((new Entity())->setDestination('place_missing', $payload, false)->destination_uuid)->toBeNull()
+        ->and($entitySaved->setDestination('missing', $payload, true))->toBe($entitySaved)
+        ->and($entitySaved->savedForTest)->toBeTrue();
+});
+
+test('entity insert get uuid updates existing entities and inserts sanitized rows', function () {
+    fleetopsEntityUnitUseConnection();
+    app('session')->forget(['company', 'api_key']);
+
+    Entity::query()->insert([
+        'uuid'        => '11111111-1111-4111-8111-111111111111',
+        'public_id'   => 'entity_existing',
+        'internal_id' => 'ENT-EXIST',
+    ]);
+
+    $payload = new Payload();
+    $payload->setRawAttributes(['uuid' => 'payload-uuid'], true);
+
+    expect(Entity::insertGetUuid(['uuid' => '11111111-1111-4111-8111-111111111111'], $payload))->toBe('11111111-1111-4111-8111-111111111111')
+        ->and(Entity::query()->where('uuid', '11111111-1111-4111-8111-111111111111')->value('payload_uuid'))->toBe('payload-uuid');
+
+    $createdUuid = Entity::insertGetUuid([
+        'name'                  => 'Inserted Parcel',
+        'type'                  => 'Box',
+        'meta'                  => ['fragile' => true],
+        'not_a_fillable_column' => 'ignored',
+    ]);
+
+    $created = Entity::query()->where('uuid', $createdUuid)->first();
+
+    expect($createdUuid)->toBeString()
+        ->and($created)->toBeInstanceOf(Entity::class)
+        ->and($created->public_id)->toStartWith('entity_')
+        ->and($created->internal_id)->toBeString()
+        ->and($created->name)->toBe('Inserted Parcel')
+        ->and($created->type)->toBe('Box')
+        ->and($created->meta)->toBe(['fragile' => true])
+        ->and(array_key_exists('not_a_fillable_column', $created->getAttributes()))->toBeFalse();
+});
+
+test('entity destinations confirm places and resolve temp search uuids', function () {
+    fleetopsEntityUnitUseConnection();
+    $connection = EloquentModel::resolveConnection('mysql');
+    $connection->table('places')->insert(['uuid' => 'place-search-1', 'company_uuid' => 'company-1', 'name' => 'Search Resolved', 'meta' => json_encode(['search_uuid' => '99999999-9999-4999-8999-999999999999'])]);
+
+    $payload = new Payload();
+    $payload->setRawAttributes(['uuid' => 'payload-entity-1'], true);
+    $payload->setRelation('waypoints', collect());
+    $payload->setRelation('pickup', null);
+    $payload->setRelation('dropoff', null);
+
+    $entity = new Entity();
+    $entity->setRawAttributes(['uuid' => 'entity-search-1'], true);
+
+    // A temp search uuid with no matching waypoint resolves through place metadata
+    $entity->setDestination('99999999-9999-4999-8999-999999999999', $payload, false);
+    expect($entity->destination_uuid)->toBe('place-search-1');
+});

package/server/tests/Unit/Models/EquipmentTest.php

@@ -0,0 +1,434 @@
+<?php
+
+if (!function_exists('Fleetbase\FleetOps\Models\session')) {
+    eval('namespace Fleetbase\FleetOps\Models; function session($key = null, $default = null) { return $key === "company" ? "company-equipment" : $default; }');
+}
+
+if (!function_exists('Fleetbase\FleetOps\Models\auth')) {
+    eval('namespace Fleetbase\FleetOps\Models; function auth() { return new class { public function user() { return null; } public function id() { return null; } }; }');
+}
+
+if (!function_exists('Fleetbase\FleetOps\Models\activity')) {
+    eval('namespace Fleetbase\FleetOps\Models; function activity($logName = null) { return \FleetOpsEquipmentActivityFake::start($logName); }');
+}
+
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\Equipment;
+use Fleetbase\FleetOps\Models\Maintenance;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Models\Warranty;
+use Fleetbase\FleetOps\Support\Utils;
+use Fleetbase\Models\File;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+use Illuminate\Database\Eloquent\Relations\MorphTo;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Support\Carbon;
+use Spatie\Activitylog\LogOptions;
+use Spatie\Sluggable\SlugOptions;
+
+class FleetOpsEquipmentActivityFake
+{
+    public static array $entries = [];
+
+    public static function start(?string $logName = null): self
+    {
+        static::$entries[] = ['log_name' => $logName];
+
+        return new self(count(static::$entries) - 1);
+    }
+
+    public function __construct(private int $index)
+    {
+    }
+
+    public function performedOn($subject): self
+    {
+        static::$entries[$this->index]['subject'] = $subject;
+
+        return $this;
+    }
+
+    public function withProperties(array $properties): self
+    {
+        static::$entries[$this->index]['properties'] = $properties;
+
+        return $this;
+    }
+
+    public function log(string $message): bool
+    {
+        static::$entries[$this->index]['message'] = $message;
+
+        return true;
+    }
+}
+
+class FleetOpsEquipmentQueryFake
+{
+    public array $calls = [];
+
+    public function where(...$arguments): self
+    {
+        $this->calls[] = ['where', $arguments];
+
+        return $this;
+    }
+
+    public function whereNotNull(string $column): self
+    {
+        $this->calls[] = ['whereNotNull', $column];
+
+        return $this;
+    }
+
+    public function whereNull(string $column): self
+    {
+        $this->calls[] = ['whereNull', $column];
+
+        return $this;
+    }
+
+    public function orWhereNull(string $column): self
+    {
+        $this->calls[] = ['orWhereNull', $column];
+
+        return $this;
+    }
+}
+
+class FleetOpsEquipmentFileFake extends File
+{
+    public function getAttribute($key)
+    {
+        return $this->attributes[$key] ?? null;
+    }
+}
+
+class FleetOpsEquipmentDatabaseProbe
+{
+    public function __construct(private SQLiteConnection $connection)
+    {
+    }
+
+    public function connection(): SQLiteConnection
+    {
+        return $this->connection;
+    }
+}
+
+class FleetOpsEquipmentUpdatingFake extends Equipment
+{
+    public array $updates = [];
+
+    public function update(array $attributes = [], array $options = []): bool
+    {
+        $this->updates[] = $attributes;
+        $this->forceFill($attributes);
+
+        return true;
+    }
+}
+
+class FleetOpsEquipmentMaintenanceRelationFake extends HasMany
+{
+    public array $wheres = [];
+    public array $orders = [];
+    public float $sum    = 0.0;
+
+    public function __construct(
+        public bool $overdueExists = false,
+        public ?Maintenance $completed = null,
+    ) {
+    }
+
+    public function where($column, $operator = null, $value = null, $boolean = 'and')
+    {
+        $this->wheres[] = [$column, $operator, $value, $boolean];
+
+        return $this;
+    }
+
+    public function orderBy($column, $direction = 'asc')
+    {
+        $this->orders[] = [$column, $direction];
+
+        return $this;
+    }
+
+    public function exists()
+    {
+        return $this->overdueExists;
+    }
+
+    public function first($columns = ['*'])
+    {
+        return $this->completed;
+    }
+
+    public function sum($column)
+    {
+        $this->wheres[] = ['sum', $column, null, 'and'];
+
+        return $this->sum;
+    }
+}
+
+class FleetOpsEquipmentMaintenanceFake extends Equipment
+{
+    public FleetOpsEquipmentMaintenanceRelationFake $maintenanceRelation;
+
+    public function maintenances(): HasMany
+    {
+        return $this->maintenanceRelation;
+    }
+}
+
+beforeEach(function () {
+    $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
+    $resolver   = new ConnectionResolver([
+        'default' => $connection,
+        'mysql'   => $connection,
+    ]);
+
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+    app()->instance('db', new FleetOpsEquipmentDatabaseProbe($connection));
+
+    FleetOpsEquipmentActivityFake::$entries = [];
+    Carbon::setTestNow(Carbon::parse('2026-07-27 12:00:00'));
+});
+
+afterEach(function () {
+    Carbon::setTestNow();
+});
+
+test('equipment relationship contracts and options are stable', function () {
+    $equipment = new Equipment();
+
+    expect($equipment->getSlugOptions())->toBeInstanceOf(SlugOptions::class)
+        ->and($equipment->getActivitylogOptions())->toBeInstanceOf(LogOptions::class)
+        ->and($equipment->warranty())->toBeInstanceOf(BelongsTo::class)
+        ->and($equipment->warranty()->getRelated())->toBeInstanceOf(Warranty::class)
+        ->and($equipment->photo())->toBeInstanceOf(BelongsTo::class)
+        ->and($equipment->photo()->getRelated())->toBeInstanceOf(File::class)
+        ->and($equipment->createdBy())->toBeInstanceOf(BelongsTo::class)
+        ->and($equipment->updatedBy())->toBeInstanceOf(BelongsTo::class)
+        ->and($equipment->equipable())->toBeInstanceOf(MorphTo::class)
+        ->and($equipment->maintenances())->toBeInstanceOf(HasMany::class)
+        ->and($equipment->maintenances()->getRelated())->toBeInstanceOf(Maintenance::class)
+        ->and($equipment->maintenances()->getForeignKeyName())->toBe('maintainable_uuid');
+});
+
+test('equipment mutators and appended accessors normalize assignment state', function () {
+    $warranty = new Warranty();
+    $warranty->forceFill(['name' => 'Cold chain warranty', 'is_active' => true]);
+
+    $photo = new FleetOpsEquipmentFileFake();
+    $photo->forceFill(['url' => 'https://example.test/equipment.png']);
+
+    $vehicle = new Vehicle();
+    $vehicle->forceFill(['name' => 'Reefer Van']);
+
+    $equipment = new Equipment([
+        'status'         => 'active',
+        'equipable_type' => 'vehicle',
+        'equipable_uuid' => 'vehicle-uuid',
+        'purchased_at'   => Carbon::now()->subYears(2),
+        'purchase_price' => 10000,
+        'meta'           => [
+            'depreciation_rate' => 0.2,
+            'replacement_cost'  => 15000,
+        ],
+    ]);
+    $equipment->setRelation('warranty', $warranty);
+    $equipment->setRelation('photo', $photo);
+    $equipment->setRelation('equipable', $vehicle);
+
+    expect($equipment->status)->toBe('available')
+        ->and($equipment->equipable_type)->toBe(Utils::getMutationType('fleet-ops:vehicle'))
+        ->and($equipment->warranty_name)->toBe('Cold chain warranty')
+        ->and($equipment->photo_url)->toBe('https://example.test/equipment.png')
+        ->and($equipment->equipped_to_name)->toBe('Reefer Van')
+        ->and($equipment->is_equipped)->toBeTrue()
+        ->and($equipment->age_in_days)->toBeGreaterThanOrEqual(730)
+        ->and($equipment->depreciated_value)->toBe(6000.0)
+        ->and($equipment->isUnderWarranty())->toBeTrue()
+        ->and($equipment->getReplacementCostEstimate())->toBe(15000.0);
+
+    $equipment = new Equipment(['equipable_type' => Driver::class]);
+    expect($equipment->equipable_type)->toBe(Driver::class);
+
+    $equipment = new Equipment(['equipable_type' => '']);
+    expect($equipment->equipable_type)->toBeNull()
+        ->and($equipment->equipped_to_name)->toBeNull()
+        ->and($equipment->is_equipped)->toBeFalse()
+        ->and($equipment->age_in_days)->toBeNull()
+        ->and($equipment->depreciated_value)->toBeNull()
+        ->and($equipment->getReplacementCostEstimate())->toBeNull();
+});
+
+test('equipment query scopes add expected filters', function () {
+    $equipment = new Equipment();
+    $query     = new FleetOpsEquipmentQueryFake();
+
+    expect($equipment->scopeByType($query, 'reefer'))->toBe($query)
+        ->and($equipment->scopeActive($query))->toBe($query)
+        ->and($equipment->scopeEquipped($query))->toBe($query)
+        ->and($equipment->scopeUnequipped($query))->toBe($query)
+        ->and($equipment->scopeByManufacturer($query, 'Thermo King'))->toBe($query)
+        ->and($query->calls)->toBe([
+            ['where', ['type', 'reefer']],
+            ['where', ['status', 'active']],
+            ['whereNotNull', 'equipable_uuid'],
+            ['whereNotNull', 'equipable_type'],
+            ['whereNull', 'equipable_uuid'],
+            ['orWhereNull', 'equipable_type'],
+            ['where', ['manufacturer', 'Thermo King']],
+        ]);
+});
+
+test('equipment assignment helpers update state and record activity payloads', function () {
+    $vehicle = new Vehicle();
+    $vehicle->forceFill(['uuid' => 'vehicle-uuid', 'name' => 'Van 42']);
+
+    $equipment = new FleetOpsEquipmentUpdatingFake();
+    $equipment->forceFill([
+        'uuid'           => 'equipment-uuid',
+        'equipable_type' => Vehicle::class,
+        'equipable_uuid' => 'old-vehicle-uuid',
+    ]);
+
+    expect($equipment->equipTo($vehicle))->toBeTrue()
+        ->and($equipment->updates[0])->toBe([
+            'equipable_type' => Vehicle::class,
+            'equipable_uuid' => 'vehicle-uuid',
+        ])
+        ->and($equipment->unequip())->toBeTrue()
+        ->and($equipment->updates[1])->toBe([
+            'equipable_type' => null,
+            'equipable_uuid' => null,
+        ])
+        ->and(FleetOpsEquipmentActivityFake::$entries[0]['log_name'])->toBe('equipment_equipped')
+        ->and(FleetOpsEquipmentActivityFake::$entries[0]['properties'])->toMatchArray([
+            'equipped_to_type' => Vehicle::class,
+            'equipped_to_uuid' => 'vehicle-uuid',
+            'equipped_to_name' => 'Van 42',
+        ])
+        ->and(FleetOpsEquipmentActivityFake::$entries[0]['message'])->toBe('Equipment equipped')
+        ->and(FleetOpsEquipmentActivityFake::$entries[1]['log_name'])->toBe('equipment_unequipped')
+        ->and(FleetOpsEquipmentActivityFake::$entries[1]['properties'])->toBe([
+            'previous_equipped_to_type' => Vehicle::class,
+            'previous_equipped_to_uuid' => 'vehicle-uuid',
+        ])
+        ->and(FleetOpsEquipmentActivityFake::$entries[1]['message'])->toBe('Equipment unequipped');
+});
+
+test('equipment maintenance helpers evaluate overdue interval utilization and costs', function () {
+    $equipment = new FleetOpsEquipmentMaintenanceFake([
+        'equipable_type' => Vehicle::class,
+        'equipable_uuid' => 'vehicle-uuid',
+        'purchased_at'   => Carbon::now()->subDays(90),
+        'meta'           => ['maintenance_interval_days' => 30],
+    ]);
+
+    $equipment->maintenanceRelation = new FleetOpsEquipmentMaintenanceRelationFake(overdueExists: true);
+
+    expect($equipment->needsMaintenance())->toBeTrue()
+        ->and($equipment->maintenanceRelation->wheres[0][0])->toBe('status')
+        ->and($equipment->getUtilizationRate())->toBe(75.0);
+
+    $completed = new Maintenance();
+    $completed->forceFill(['completed_at' => Carbon::now()->subDays(45)]);
+
+    $equipment->maintenanceRelation = new FleetOpsEquipmentMaintenanceRelationFake(completed: $completed);
+
+    expect($equipment->needsMaintenance())->toBeTrue()
+        ->and($equipment->maintenanceRelation->orders)->toBe([['completed_at', 'desc']]);
+
+    $equipment->maintenanceRelation      = new FleetOpsEquipmentMaintenanceRelationFake();
+    $equipment->maintenanceRelation->sum = 123.45;
+
+    expect($equipment->getMaintenanceCost(60))->toBe(123.45)
+        ->and($equipment->maintenanceRelation->wheres[0][0])->toBe('status')
+        ->and($equipment->maintenanceRelation->wheres[1][0])->toBe('completed_at');
+
+    $equipment                      = new FleetOpsEquipmentMaintenanceFake();
+    $equipment->maintenanceRelation = new FleetOpsEquipmentMaintenanceRelationFake();
+
+    expect($equipment->needsMaintenance())->toBeFalse()
+        ->and($equipment->getUtilizationRate())->toBe(0.0);
+});
+
+test('equipment replacement estimates and import rows hydrate defaults', function () {
+    $equipment = new Equipment([
+        'purchase_price' => 10000,
+        'purchased_at'   => Carbon::now()->subYears(2),
+        'meta'           => ['inflation_rate' => 0.05],
+    ]);
+
+    expect(round($equipment->getReplacementCostEstimate(), 2))->toBe(11025.0);
+
+    $equipment = Equipment::createFromImport([
+        'name'            => 'Liftgate',
+        'internal_id'     => 'LG-100',
+        'serial'          => 'SERIAL-100',
+        'brand'           => 'Fleet Gear',
+        'equipment_model' => 'Heavy Lift',
+        'cost'            => 450000,
+        'currency'        => 'sgd',
+        'purchase_date'   => '2025-05-01',
+    ]);
+
+    expect($equipment->company_uuid)->toBe('company-equipment')
+        ->and($equipment->name)->toBe('Liftgate')
+        ->and($equipment->code)->toBe('LG-100')
+        ->and($equipment->type)->toBe('equipment')
+        ->and($equipment->status)->toBe('operational')
+        ->and($equipment->serial_number)->toBe('SERIAL-100')
+        ->and($equipment->manufacturer)->toBe('Fleet Gear')
+        ->and($equipment->model)->toBe('Heavy Lift')
+        ->and($equipment->currency)->toBe('SGD')
+        ->and($equipment->purchased_at->toDateString())->toBe('2025-05-01');
+});
+
+test('equipable types match maintenance scheduling and warranty imports resolve', function () {
+    $connection = app('db')->connection();
+    $schema     = $connection->getSchemaBuilder();
+    foreach (['maintenances' => ['uuid', 'public_id', 'company_uuid', 'maintainable_type', 'maintainable_uuid', 'type', 'status', 'scheduled_at', 'summary', 'notes', 'created_by_uuid', '_key'], 'warranties' => ['uuid', 'public_id', 'company_uuid', 'name', 'provider', 'expires_at', '_key'], 'equipments' => ['uuid', 'public_id', 'company_uuid', 'name', 'internal_id', 'code', 'type', 'status', 'serial_number', 'manufacturer', 'model', 'purchase_price', 'currency', 'purchased_at', 'warranty_uuid', 'equipable_type', 'equipable_uuid', '_key']] as $table => $columns) {
+        $schema->create($table, function ($blueprint) use ($columns) {
+            $blueprint->increments('id');
+            foreach ($columns as $column) {
+                $blueprint->string($column)->nullable();
+            }
+            $blueprint->timestamps();
+            $blueprint->timestamp('deleted_at')->nullable();
+        });
+    }
+
+    // Equipable type mutator maps known aliases through mutation types
+    $equipment                 = new Equipment();
+    $equipment->equipable_type = 'vehicle';
+    expect($equipment->getAttributes()['equipable_type'])->toContain('Vehicle');
+    $equipment->equipable_type = 'fleet-ops:driver';
+    expect($equipment->getAttributes()['equipable_type'])->toContain('Driver');
+    $equipment->equipable_type = 'Custom\\Type';
+    expect($equipment->getAttributes()['equipable_type'])->toBe('Custom\\Type');
+
+    // Scheduling maintenance persists a scheduled row against the equipment
+    $equipment->setRawAttributes(['uuid' => 'equip-sched-1', 'company_uuid' => 'company-equipment'], true);
+    $maintenance = $equipment->scheduleMaintenance('inspection', new DateTime('2026-08-01 10:00:00'), ['summary' => 'Quarterly check']);
+    expect($connection->table('maintenances')->where('type', 'inspection')->count())->toBe(1)
+        ->and($connection->table('maintenances')->value('summary'))->toBe('Quarterly check');
+
+    // Import rows resolve warranties by fuzzy name match
+    $connection->table('warranties')->insert(['uuid' => 'warranty-1', 'company_uuid' => 'company-equipment', 'name' => 'Extended Coverage Plan']);
+    $imported = Equipment::createFromImport([
+        'name'     => 'Imported Lift',
+        'warranty' => 'Extended Coverage',
+    ], true);
+    expect($imported->warranty_uuid)->toBe('warranty-1')
+        ->and($connection->table('equipments')->where('name', 'Imported Lift')->count())->toBe(1);
+});