@fleetbase/fleetops-engine 0.6.58 → 0.6.59

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

@@ -0,0 +1,161 @@
+<?php
+
+if (!function_exists('Fleetbase\Support\session')) {
+    eval('namespace Fleetbase\Support; function session($key = null, $default = null) { if ($key === null) { return new class { public function has($k) { return \session($k) !== null; } public function get($k, $d = null) { return \session($k, $d); } }; } return \session($key, $default); }');
+}
+
+if (!function_exists('Fleetbase\Support\auth')) {
+    eval('namespace Fleetbase\Support; function auth() { return new class { public function user() { return null; } public function id() { return null; } }; }');
+}
+
+if (!function_exists('Cknow\Money\config')) {
+    eval('namespace Cknow\Money; function config($key = null, $default = null) { return $default; }');
+}
+
+use Fleetbase\FleetOps\Models\Maintenance;
+use Fleetbase\FleetOps\Models\WorkOrder;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+/**
+ * Covers Maintenance and WorkOrder import-row creation against SQLite:
+ * maintainable and target resolution by vehicle name with the equipment
+ * fallback, performer and vendor assignee resolution, lifecycle guard
+ * returns for start and complete, duration efficiency fallbacks, work
+ * order code generation on create, and line-item normalization from
+ * strings and invalid values.
+ */
+function fleetopsMaintenanceImportBoot(): SQLiteConnection
+{
+    $pdo = new PDO('sqlite::memory:');
+    $pdo->sqliteCreateFunction('ST_PointFromText', fn ($wkt, $srid = 0, $axisOrder = null) => $wkt);
+    $pdo->sqliteCreateFunction('ST_GeomFromText', fn ($wkt, $srid = 0, $axisOrder = null) => $wkt);
+    $pdo->sqliteCreateFunction('CONCAT', fn (...$parts) => implode('', array_map(fn ($part) => (string) $part, $parts)));
+    $connection = new SQLiteConnection($pdo);
+    $resolver   = new ConnectionResolver(['default' => $connection, 'mysql' => $connection]);
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+    EloquentModel::setEventDispatcher(new Illuminate\Events\Dispatcher());
+    app()->instance('db', new class($connection) {
+        public function __construct(public SQLiteConnection $c)
+        {
+        }
+
+        public function connection($name = null): SQLiteConnection
+        {
+            return $this->c;
+        }
+
+        public function __call($method, $arguments)
+        {
+            return $this->c->{$method}(...$arguments);
+        }
+    });
+    Illuminate\Support\Facades\DB::clearResolvedInstance('db');
+
+    app()->instance('responsecache', new class {
+        public function __call($method, $arguments)
+        {
+            return null;
+        }
+    });
+
+    $schema = $connection->getSchemaBuilder();
+    $tables = [
+        'maintenances' => ['uuid', 'public_id', 'company_uuid', 'maintainable_type', 'maintainable_uuid', 'maintainable_id', 'performed_by_type', 'performed_by_uuid', 'type', 'status', 'priority', 'summary', 'notes', 'scheduled_at', 'started_at', 'completed_at', 'odometer', 'engine_hours', 'labor_cost', 'parts_cost', 'tax', 'total_cost', 'currency', 'line_items', 'meta', '_key'],
+        'work_orders'  => ['uuid', 'public_id', 'company_uuid', 'code', 'subject', 'category', 'status', 'priority', 'instructions', 'opened_at', 'due_at', 'estimated_cost', 'approved_budget', 'actual_cost', 'currency', 'cost_center', 'budget_code', 'target_type', 'target_uuid', 'assignee_type', 'assignee_uuid', 'meta', 'line_items', '_key'],
+        'vehicles'     => ['uuid', 'public_id', 'company_uuid', 'name', 'make', 'model', 'year', 'plate_number', 'internal_id', 'vin', 'serial_number', 'call_sign', 'fuel_card_number', 'location', 'online'],
+        'equipments'   => ['uuid', 'public_id', 'company_uuid', 'name', 'serial_number', 'type', 'status'],
+        'vendors'      => ['uuid', 'public_id', 'company_uuid', 'name', 'type', 'status'],
+        'drivers'      => ['uuid', 'public_id', 'company_uuid', 'user_uuid', 'location', 'online'],
+        'users'        => ['uuid', 'public_id', 'company_uuid', 'name', 'type', 'status'],
+    ];
+    foreach ($tables 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();
+        });
+    }
+
+    config()->set('activitylog.enabled', false);
+    config()->set('activitylog.default_auth_driver', 'web');
+    app()->bind(Illuminate\Contracts\Config\Repository::class, fn () => config());
+
+    session(['company' => 'company-1']);
+
+    return $connection;
+}
+
+test('maintenance imports resolve vehicles equipment and performers', function () {
+    $connection = fleetopsMaintenanceImportBoot();
+    $connection->table('vehicles')->insert(['uuid' => 'vehicle-1', 'public_id' => 'vehicle_maint1', 'company_uuid' => 'company-1', 'name' => 'Van 12', 'plate_number' => 'SGV1234A']);
+    $connection->table('equipments')->insert(['uuid' => 'equip-1', 'public_id' => 'equipment_maint1', 'company_uuid' => 'company-1', 'name' => 'Generator Alpha', 'serial_number' => 'GEN-9']);
+    $connection->table('users')->insert(['uuid' => 'user-1', 'company_uuid' => 'company-1', 'name' => 'Mech', 'type' => 'user']);
+    $connection->table('drivers')->insert(['uuid' => 'driver-1', 'public_id' => 'driver_maint1', 'company_uuid' => 'company-1', 'user_uuid' => 'user-1']);
+
+    $withVehicle = Maintenance::createFromImport([
+        'summary'      => 'Oil change',
+        'vehicle'      => 'SGV1234A',
+        'performed_by' => 'driver_maint1',
+        'labor_cost'   => '150.00',
+    ], true);
+    expect($withVehicle->maintainable_uuid)->toBe('vehicle-1')
+        ->and($withVehicle->performed_by_uuid)->toBe('driver-1')
+        ->and($connection->table('maintenances')->count())->toBe(1);
+
+    $withEquipment = Maintenance::createFromImport([
+        'summary' => 'Generator service',
+        'vehicle' => 'Generator Alpha',
+    ]);
+    expect($withEquipment->maintainable_uuid)->toBe('equip-1');
+});
+
+test('maintenance lifecycle guards efficiency and line items normalize', function () {
+    fleetopsMaintenanceImportBoot();
+
+    $completed = new Maintenance();
+    $completed->setRawAttributes(['uuid' => 'm-1', 'status' => 'completed'], true);
+    expect($completed->start())->toBeFalse()
+        ->and($completed->complete())->toBeFalse();
+
+    // Efficiency without estimated hours resolves to null
+    $noEstimate = new Maintenance();
+    $noEstimate->setRawAttributes(['uuid' => 'm-2', 'meta' => json_encode([]), 'started_at' => '2026-07-01 08:00:00', 'completed_at' => '2026-07-01 10:00:00'], true);
+    expect($noEstimate->duration_efficiency)->toBeNull();
+
+    // Line items normalize from json strings and reject scalars
+    $maintenance             = new Maintenance();
+    $maintenance->line_items = json_encode([['description' => 'Filter', 'unit_cost' => '25.00', 'quantity' => 1]]);
+    expect(json_decode($maintenance->getAttributes()['line_items'], true))->toHaveCount(1);
+
+    $maintenance->line_items = 12345;
+    expect(json_decode($maintenance->getAttributes()['line_items'], true))->toBe([]);
+});
+
+test('work order imports resolve targets assignees and generate codes', function () {
+    $connection = fleetopsMaintenanceImportBoot();
+    $connection->table('vehicles')->insert(['uuid' => 'vehicle-1', 'public_id' => 'vehicle_wo1', 'company_uuid' => 'company-1', 'name' => 'Truck 7', 'plate_number' => 'SGT7777B']);
+    $connection->table('equipments')->insert(['uuid' => 'equip-1', 'public_id' => 'equipment_wo1', 'company_uuid' => 'company-1', 'name' => 'Crane Beta', 'serial_number' => 'CRN-2']);
+    $connection->table('vendors')->insert(['uuid' => 'vendor-1', 'public_id' => 'vendor_wo1', 'company_uuid' => 'company-1', 'name' => 'FixIt Repairs']);
+
+    $withVehicle = WorkOrder::createFromImport([
+        'subject' => 'Brake inspection',
+        'vehicle' => 'SGT7777B',
+        'vendor'  => 'FixIt',
+    ], true);
+    expect($withVehicle->target_uuid)->toBe('vehicle-1')
+        ->and($withVehicle->assignee_uuid)->toBe('vendor-1')
+        ->and($withVehicle->code)->toStartWith('WO-')
+        ->and($connection->table('work_orders')->count())->toBe(1);
+
+    $withEquipment = WorkOrder::createFromImport([
+        'subject' => 'Crane check',
+        'vehicle' => 'Crane Beta',
+    ]);
+    expect($withEquipment->target_uuid)->toBe('equip-1');
+});

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

@@ -0,0 +1,121 @@
+<?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 Carbon\Carbon;
+use Fleetbase\FleetOps\Models\Manifest;
+use Fleetbase\FleetOps\Models\ManifestStop;
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Models\Place;
+use Fleetbase\FleetOps\Models\Waypoint;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\SQLiteConnection;
+
+class FleetOpsManifestStopModelProbe extends ManifestStop
+{
+    public array $updates = [];
+
+    public function update(array $attributes = [], array $options = []): bool
+    {
+        $this->updates[] = $attributes;
+        $this->forceFill($attributes);
+
+        return true;
+    }
+}
+
+class FleetOpsManifestStopManifestProbe extends Manifest
+{
+    public int $autoCompleteChecks = 0;
+
+    public function checkAndAutoComplete(): void
+    {
+        $this->autoCompleteChecks++;
+    }
+}
+
+function fleetopsManifestStopUseRelationConnection(): void
+{
+    $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
+    $resolver   = new ConnectionResolver([
+        'default' => $connection,
+        'mysql'   => $connection,
+    ]);
+
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+}
+
+test('manifest stop relationship contracts resolve expected models', function () {
+    fleetopsManifestStopUseRelationConnection();
+
+    $stop = new ManifestStop();
+
+    expect($stop->manifest())->toBeInstanceOf(BelongsTo::class)
+        ->and($stop->manifest()->getRelated())->toBeInstanceOf(Manifest::class)
+        ->and($stop->order())->toBeInstanceOf(BelongsTo::class)
+        ->and($stop->order()->getRelated())->toBeInstanceOf(Order::class)
+        ->and($stop->place())->toBeInstanceOf(BelongsTo::class)
+        ->and($stop->place()->getRelated())->toBeInstanceOf(Place::class)
+        ->and($stop->waypoint())->toBeInstanceOf(BelongsTo::class)
+        ->and($stop->waypoint()->getRelated())->toBeInstanceOf(Waypoint::class);
+});
+
+test('manifest stop exposes tracking number and address fallbacks', function () {
+    $trackingNumber = (object) ['tracking_number' => 'TRACK-001'];
+    $dropoff        = (object) ['address' => 'Payload dropoff address'];
+    $payload        = (object) ['dropoff' => $dropoff];
+
+    $order = new Order();
+    $order->setRelation('trackingNumber', $trackingNumber);
+    $order->setRelation('payload', $payload);
+
+    $place = new Place();
+    $place->setRawAttributes(['street1' => 'Place address'], true);
+
+    $stop = new ManifestStop();
+    $stop->setRelation('order', $order);
+    $stop->setRelation('place', $place);
+
+    expect($stop->tracking_number)->toBe('TRACK-001')
+        ->and($stop->address)->toBe('PLACE ADDRESS');
+
+    $stop->unsetRelation('place');
+
+    expect($stop->address)->toBe('Payload dropoff address')
+        ->and((new ManifestStop())->tracking_number)->toBeNull()
+        ->and((new ManifestStop())->address)->toBeNull();
+});
+
+test('manifest stop status helpers update state and trigger manifest checks', function () {
+    Carbon::setTestNow(Carbon::parse('2026-08-04 09:30:00'));
+
+    $manifest = new FleetOpsManifestStopManifestProbe();
+    $stop     = new FleetOpsManifestStopModelProbe();
+    $stop->setRelation('manifest', $manifest);
+
+    expect($stop->markArrived())->toBe($stop)
+        ->and($stop->updates[0]['status'])->toBe('arrived')
+        ->and($stop->updates[0]['actual_arrival']->toDateTimeString())->toBe('2026-08-04 09:30:00')
+        ->and($stop->status)->toBe('arrived');
+
+    expect($stop->markCompleted())->toBe($stop)
+        ->and($stop->updates[1])->toBe(['status' => 'completed'])
+        ->and($manifest->autoCompleteChecks)->toBe(1)
+        ->and($stop->status)->toBe('completed');
+
+    expect($stop->markSkipped())->toBe($stop)
+        ->and($stop->updates[2])->toBe(['status' => 'skipped'])
+        ->and($manifest->autoCompleteChecks)->toBe(2)
+        ->and($stop->status)->toBe('skipped');
+
+    Carbon::setTestNow();
+});

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

@@ -0,0 +1,163 @@
+<?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 Carbon\Carbon;
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\Manifest;
+use Fleetbase\FleetOps\Models\ManifestStop;
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Models\Vehicle;
+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\SQLiteConnection;
+
+class FleetOpsManifestModelProbe extends Manifest
+{
+    public array $updates = [];
+
+    public function update(array $attributes = [], array $options = []): bool
+    {
+        $this->updates[] = $attributes;
+        $this->forceFill($attributes);
+
+        return true;
+    }
+}
+
+function fleetopsManifestUseInMemoryConnection(): SQLiteConnection
+{
+    $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
+    $connection->statement('create table manifest_stops (
+        id integer primary key autoincrement,
+        manifest_uuid varchar(64),
+        status varchar(32),
+        sequence integer null,
+        deleted_at datetime null
+    )');
+
+    $resolver = new ConnectionResolver([
+        'default' => $connection,
+        'mysql'   => $connection,
+    ]);
+
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+
+    return $connection;
+}
+
+test('manifest relationship contracts resolve expected models', function () {
+    fleetopsManifestUseInMemoryConnection();
+
+    $manifest = new Manifest();
+
+    expect($manifest->driver())->toBeInstanceOf(BelongsTo::class)
+        ->and($manifest->driver()->getRelated())->toBeInstanceOf(Driver::class)
+        ->and($manifest->vehicle())->toBeInstanceOf(BelongsTo::class)
+        ->and($manifest->vehicle()->getRelated())->toBeInstanceOf(Vehicle::class)
+        ->and($manifest->stops())->toBeInstanceOf(HasMany::class)
+        ->and($manifest->stops()->getRelated())->toBeInstanceOf(ManifestStop::class)
+        ->and($manifest->orders())->toBeInstanceOf(HasMany::class)
+        ->and($manifest->orders()->getRelated())->toBeInstanceOf(Order::class);
+});
+
+test('manifest exposes driver vehicle and stop count accessors', function () {
+    $connection = fleetopsManifestUseInMemoryConnection();
+    $connection->table('manifest_stops')->insert([
+        ['manifest_uuid' => 'manifest-uuid', 'status' => 'completed', 'sequence' => 1],
+        ['manifest_uuid' => 'manifest-uuid', 'status' => 'pending', 'sequence' => 2],
+        ['manifest_uuid' => 'manifest-uuid', 'status' => 'arrived', 'sequence' => 3],
+        ['manifest_uuid' => 'manifest-uuid', 'status' => 'skipped', 'sequence' => 4],
+    ]);
+
+    $driver = new Driver();
+    $driver->setRelation('user', (object) ['name' => 'Dispatch Driver']);
+
+    $vehicle = new Vehicle();
+    $vehicle->setRawAttributes(['name' => 'Truck 12'], true);
+
+    $manifest = new Manifest();
+    $manifest->setRawAttributes(['uuid' => 'manifest-uuid'], true);
+    $manifest->setRelation('driver', $driver);
+    $manifest->setRelation('vehicle', $vehicle);
+
+    expect($manifest->driver_name)->toBe('Dispatch Driver')
+        ->and($manifest->vehicle_name)->toBe('Truck 12')
+        ->and($manifest->completed_stops)->toBe(1)
+        ->and($manifest->pending_stops)->toBe(2);
+});
+
+test('manifest scopes apply company driver vehicle and active status filters', function () {
+    fleetopsManifestUseInMemoryConnection();
+
+    $companyQuery = Manifest::query();
+    (new Manifest())->scopeForCompany($companyQuery, 'company-uuid');
+
+    $driverQuery = Manifest::query();
+    (new Manifest())->scopeForDriver($driverQuery, 'driver-uuid');
+
+    $vehicleQuery = Manifest::query();
+    (new Manifest())->scopeForVehicle($vehicleQuery, 'vehicle-uuid');
+
+    $activeQuery = Manifest::query();
+    (new Manifest())->scopeActive($activeQuery);
+
+    expect($companyQuery->getQuery()->wheres[0])->toMatchArray(['column' => 'company_uuid', 'value' => 'company-uuid'])
+        ->and($driverQuery->getQuery()->wheres[0])->toMatchArray(['column' => 'driver_uuid', 'value' => 'driver-uuid'])
+        ->and($vehicleQuery->getQuery()->wheres[0])->toMatchArray(['column' => 'vehicle_uuid', 'value' => 'vehicle-uuid'])
+        ->and($activeQuery->getQuery()->wheres[0]['type'])->toBe('In')
+        ->and($activeQuery->getQuery()->wheres[0]['column'])->toBe('status')
+        ->and($activeQuery->getQuery()->wheres[0]['values'])->toBe(['active', 'in_progress']);
+});
+
+test('manifest lifecycle helpers update state and auto-complete only when no pending stops remain', function () {
+    $connection = fleetopsManifestUseInMemoryConnection();
+    Carbon::setTestNow(Carbon::parse('2026-08-05 13:45:00'));
+
+    $manifest = new FleetOpsManifestModelProbe();
+    $manifest->setRawAttributes(['uuid' => 'manifest-uuid', 'status' => 'active'], true);
+
+    expect($manifest->start())->toBe($manifest)
+        ->and($manifest->updates[0]['status'])->toBe('in_progress')
+        ->and($manifest->updates[0]['started_at']->toDateTimeString())->toBe('2026-08-05 13:45:00');
+
+    expect($manifest->cancel())->toBe($manifest)
+        ->and($manifest->updates[1])->toBe(['status' => 'cancelled']);
+
+    expect($manifest->complete())->toBe($manifest)
+        ->and($manifest->updates[2]['status'])->toBe('completed')
+        ->and($manifest->updates[2]['completed_at']->toDateTimeString())->toBe('2026-08-05 13:45:00');
+
+    $pendingManifest = new FleetOpsManifestModelProbe();
+    $pendingManifest->setRawAttributes(['uuid' => 'pending-manifest', 'status' => 'in_progress'], true);
+    $connection->table('manifest_stops')->insert([
+        ['manifest_uuid' => 'pending-manifest', 'status' => 'pending'],
+    ]);
+
+    $pendingManifest->checkAndAutoComplete();
+
+    expect($pendingManifest->updates)->toBe([]);
+
+    $readyManifest = new FleetOpsManifestModelProbe();
+    $readyManifest->setRawAttributes(['uuid' => 'ready-manifest', 'status' => 'in_progress'], true);
+    $connection->table('manifest_stops')->insert([
+        ['manifest_uuid' => 'ready-manifest', 'status' => 'completed'],
+        ['manifest_uuid' => 'ready-manifest', 'status' => 'skipped'],
+    ]);
+
+    $readyManifest->checkAndAutoComplete();
+
+    expect($readyManifest->updates[0]['status'])->toBe('completed')
+        ->and($readyManifest->updates[0]['completed_at']->toDateTimeString())->toBe('2026-08-05 13:45:00');
+
+    Carbon::setTestNow();
+});

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

@@ -0,0 +1,149 @@
+<?php
+
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\Equipment;
+use Fleetbase\FleetOps\Models\TrackingNumber;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Models\VehicleDevice;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+/**
+ * Covers the lookup fallbacks models take when a relation is not already
+ * loaded, plus the pass-through arms of the attribute mutators. Behaviour
+ * tests set the relations up front, so the queries behind them never run.
+ */
+function fleetopsLookupSeamBoot(): SQLiteConnection
+{
+    $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
+    $resolver   = new ConnectionResolver(['default' => $connection, 'mysql' => $connection]);
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+    app()->instance('db', new class($connection) {
+        public function __construct(public SQLiteConnection $c)
+        {
+        }
+
+        public function connection($name = null): SQLiteConnection
+        {
+            return $this->c;
+        }
+
+        public function __call($method, $arguments)
+        {
+            return $this->c->{$method}(...$arguments);
+        }
+    });
+    Illuminate\Support\Facades\DB::clearResolvedInstance('db');
+
+    $schema  = $connection->getSchemaBuilder();
+    $columns = ['uuid', 'public_id', 'company_uuid', 'user_uuid', 'vehicle_uuid', 'device_uuid', 'name', 'type', 'status', 'tracking_number', 'region', 'owner_uuid', '_key'];
+    foreach (['users', 'drivers', 'vehicles', 'vehicle_devices', 'tracking_numbers'] as $table) {
+        $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();
+        });
+    }
+
+    session(['company' => 'company-lookup-1']);
+
+    return $connection;
+}
+
+test('drivers fall back to a direct user lookup when the relation is empty', function () {
+    $connection = fleetopsLookupSeamBoot();
+    $connection->table('users')->insert([
+        'uuid'         => '33333333-3333-4333-8333-333333333333',
+        'company_uuid' => 'company-lookup-1',
+        'name'         => 'Linked Account',
+    ]);
+
+    // The relation is scoped and column-selective, so it can come back empty
+    // for a row the plain uuid lookup still finds — that mismatch is the whole
+    // reason the fallback exists.
+    $driver = new class extends Driver {
+        public function user()
+        {
+            return $this->belongsTo(Fleetbase\Models\User::class)->whereRaw('1 = 0');
+        }
+    };
+    $driver->setRawAttributes([
+        'uuid'      => 'driver-lookup-1',
+        'user_uuid' => '33333333-3333-4333-8333-333333333333',
+    ], true);
+
+    expect($driver->getUser()?->name)->toBe('Linked Account');
+
+    // A non-uuid user reference is not worth a query
+    $unlinked = new class extends Driver {
+        public function user()
+        {
+            return $this->belongsTo(Fleetbase\Models\User::class)->whereRaw('1 = 0');
+        }
+    };
+    $unlinked->setRawAttributes(['uuid' => 'driver-lookup-2', 'user_uuid' => 'not-a-uuid'], true);
+    expect($unlinked->getUser())->toBeNull();
+});
+
+test('vehicle devices fall back to a direct vehicle lookup by uuid', function () {
+    $connection = fleetopsLookupSeamBoot();
+    $connection->table('vehicles')->insert([
+        'uuid'         => 'vehicle-lookup-1',
+        'public_id'    => 'vehicle_lookupone',
+        'company_uuid' => 'company-lookup-1',
+    ]);
+
+    $device = new class extends VehicleDevice {
+        public function vehicle()
+        {
+            return $this->belongsTo(Vehicle::class)->whereRaw('1 = 0');
+        }
+    };
+    $device->setRawAttributes(['uuid' => 'vd-lookup-1', 'vehicle_uuid' => 'vehicle-lookup-1'], true);
+
+    // The relation comes back empty; the uuid still resolves the vehicle, and
+    // the callback only fires once something was found.
+    $seen = [];
+    expect($device->getVehicle(function ($vehicle) use (&$seen) { $seen[] = $vehicle->public_id; }))
+        ->toBeInstanceOf(Vehicle::class)
+        ->and($seen)->toBe(['vehicle_lookupone']);
+});
+
+test('unrecognised equipable types are stored verbatim', function () {
+    $equipment = new Equipment();
+
+    // Known short names map onto their fully qualified model class
+    $equipment->equipable_type = 'vehicle';
+    expect($equipment->getAttributes()['equipable_type'])->toContain('Vehicle');
+
+    // Anything else is kept as given rather than silently dropped
+    $equipment->equipable_type = 'trailer';
+    expect($equipment->getAttributes()['equipable_type'])->toBe('trailer');
+});
+
+test('tracking number generation redraws when the first number is already taken', function () {
+    $connection = fleetopsLookupSeamBoot();
+    $connection->table('tracking_numbers')->insert([
+        'uuid'            => 'tn-lookup-1',
+        'company_uuid'    => 'company-lookup-1',
+        'tracking_number' => 'SGTAKEN0001',
+    ]);
+
+    // Random draws practically never collide, so the redraw is only reachable
+    // by pinning the sequence.
+    $probe = new class extends TrackingNumber {
+        public static array $sequence = ['SGTAKEN0001', 'SGFREE00002'];
+
+        public static function generateTrackingNumber($region = 'SG', $length = 10): string
+        {
+            return array_shift(static::$sequence);
+        }
+    };
+
+    expect($probe::generateNumber('SG', 10))->toBe('SGFREE00002');
+});