@fleetbase/fleetops-engine 0.6.64 → 0.6.65

package/server/tests/TrailerSupportCoverageTest.php

@@ -0,0 +1,524 @@
+<?php
+
+use Fleetbase\FleetOps\Exports\TrailerExport;
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\SearchController;
+use Fleetbase\FleetOps\Http\Filter\EquipmentFilter;
+use Fleetbase\FleetOps\Http\Filter\TrailerFilter;
+use Fleetbase\FleetOps\Http\Requests\CreateTrailerRequest;
+use Fleetbase\FleetOps\Http\Requests\UpdateTrailerRequest;
+use Fleetbase\FleetOps\Http\Resources\v1\AssetConnection as AssetConnectionResource;
+use Fleetbase\FleetOps\Http\Resources\v1\Trailer as TrailerResource;
+use Fleetbase\FleetOps\Imports\TrailerImport;
+use Fleetbase\FleetOps\Models\Asset;
+use Fleetbase\FleetOps\Models\AssetConnection;
+use Fleetbase\FleetOps\Models\Device;
+use Fleetbase\FleetOps\Models\DeviceInstallation;
+use Fleetbase\FleetOps\Models\Equipment;
+use Fleetbase\FleetOps\Models\Trailer;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\LaravelMysqlSpatial\Eloquent\SpatialTrait;
+use Illuminate\Config\Repository;
+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\Http\Request;
+use Illuminate\Support\Carbon;
+use Illuminate\Support\Collection;
+use Illuminate\Validation\ValidationException;
+
+if (!class_exists('Illuminate\\Validation\\Rule')) {
+    eval('namespace Illuminate\\Validation; class Rule { public function __construct(private string $rule = "") {} public static function requiredIf($condition): string { return (is_callable($condition) ? $condition() : $condition) ? "required" : "nullable"; } public static function in(array $values): self { return new self("in:" . implode(",", $values)); } public function __toString(): string { return $this->rule; } }');
+}
+
+class FleetOpsTrailerFilterBuilder
+{
+    public array $calls = [];
+
+    public function __call(string $method, array $arguments): static
+    {
+        $this->calls[] = [$method, ...$arguments];
+        foreach ($arguments as $argument) {
+            if ($argument instanceof Closure) {
+                $argument($this);
+            }
+        }
+
+        return $this;
+    }
+
+    public function called(string $method): bool
+    {
+        return collect($this->calls)->contains(fn ($call) => $call[0] === $method);
+    }
+}
+
+class FleetOpsTrailerHistoryDevice extends Device
+{
+    public function update(array $attributes = [], array $options = []): bool
+    {
+        $this->forceFill($attributes);
+
+        return false;
+    }
+}
+
+function fleetOpsTrailerSupportDatabase(): 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);
+    $connection = new SQLiteConnection($pdo);
+    $resolver   = new ConnectionResolver(['default' => $connection, 'mysql' => $connection]);
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+    EloquentModel::setEventDispatcher(new Illuminate\Events\Dispatcher());
+    // Model hooks bind to the dispatcher present when a class boots; re-boot so the
+    // hooks of models booted by earlier test files land on this dispatcher.
+    EloquentModel::clearBootedModels();
+    $config = new Repository(['activitylog' => ['enabled' => false, 'default_auth_driver' => null, 'default_log_name' => 'default']]);
+    app()->instance('config', $config);
+    app()->instance(Illuminate\Contracts\Config\Repository::class, $config);
+    app()->instance('responsecache', new class {
+        public function __call($method, $arguments)
+        {
+            return null;
+        }
+    });
+    app()->instance('db', new class($connection) {
+        public function __construct(public SQLiteConnection $connection)
+        {
+        }
+
+        public function connection($name = null): SQLiteConnection
+        {
+            return $this->connection;
+        }
+
+        public function __call($method, $arguments)
+        {
+            return $this->connection->{$method}(...$arguments);
+        }
+    });
+    Illuminate\Support\Facades\DB::clearResolvedInstance('db');
+
+    $schema = $connection->getSchemaBuilder();
+    $schema->create('assets', function ($table) {
+        $table->increments('id');
+        foreach (['uuid', 'public_id', 'company_uuid', 'name', 'code', 'description', 'type', 'asset_class', 'status', 'vin', 'plate_number', 'serial_number', 'make', 'model', 'year', 'length', 'width', 'height', 'tare_weight', 'gvwr', 'payload_capacity', 'cargo_volume', 'axle_count', 'tire_count', 'coupling_type', 'brake_type', 'refrigerated', 'measurement_system', 'odometer', 'odometer_unit', 'ownership_type', 'purchased_at', 'lease_expires_at', 'notes', 'slug', '_key'] as $column) {
+            $table->string($column)->nullable();
+        }
+        $table->timestamps();
+        $table->softDeletes();
+    });
+    foreach (['vehicles', 'devices', 'equipments', 'asset_connections'] as $name) {
+        $schema->create($name, function ($table) {
+            $table->increments('id');
+            foreach (['uuid', 'public_id', 'company_uuid', 'name', 'display_name', 'plate_number', 'device_uuid', 'attachable_type', 'attachable_uuid', 'connector_type', 'connector_uuid', 'connected_type', 'connected_uuid'] as $column) {
+                $table->string($column)->nullable();
+            }
+            $table->timestamps();
+            $table->softDeletes();
+        });
+    }
+    $schema->create('device_installations', function ($table) {
+        $table->increments('id');
+        foreach (['uuid', 'company_uuid', 'device_uuid', 'attachable_type', 'attachable_uuid', 'active_device_uuid', 'installed_at', 'removed_at', 'source', 'metadata'] as $column) {
+            $table->string($column)->nullable();
+        }
+        $table->timestamps();
+        $table->softDeletes();
+    });
+    $schema->create('custom_field_values', function ($table) {
+        $table->increments('id');
+        foreach (['uuid', 'company_uuid', 'custom_field_uuid', 'subject_uuid', 'subject_type', 'value', 'value_type'] as $column) {
+            $table->string($column)->nullable();
+        }
+        $table->timestamps();
+        $table->softDeletes();
+    });
+    $schema->create('custom_fields', function ($table) {
+        $table->increments('id');
+        foreach (['uuid', 'company_uuid', 'label', 'name', 'type'] as $column) {
+            $table->string($column)->nullable();
+        }
+        $table->timestamps();
+        $table->softDeletes();
+    });
+    session(['company' => 'company-trailer-support']);
+
+    return $connection;
+}
+
+class FleetOpsTrailerSupportRoute
+{
+    public array $action = [];
+
+    public function __construct(private string $uri)
+    {
+    }
+
+    public function uri(): string
+    {
+        return $this->uri;
+    }
+}
+
+function fleetOpsTrailerFilter(FleetOpsTrailerFilterBuilder $builder, array $query = [], bool $internal = false): TrailerFilter
+{
+    $request = Request::create('/int/v1/trailers', 'GET', $query);
+    if ($internal) {
+        $request->setRouteResolver(fn () => new FleetOpsTrailerSupportRoute('int/v1/trailers'));
+    }
+    $session = app('session.store');
+    $session->put('company', 'company-trailer-support');
+    $request->setLaravelSession($session);
+    $filter     = new TrailerFilter($request);
+    $reflection = new ReflectionClass($filter);
+    $property   = $reflection->getParentClass()->getProperty('builder');
+    $property->setAccessible(true);
+    $property->setValue($filter, $builder);
+
+    return $filter;
+}
+
+test('trailer request authorization and validation expose the complete contract', function () {
+    $request = CreateTrailerRequest::create('/v1/trailers', 'POST');
+    $request->setLaravelSession(app('session.store'));
+    app()->instance('request', $request);
+    expect($request->authorize())->toBeFalse();
+
+    $request->session()->put('api_credential', 'credential');
+    expect($request->authorize())->toBeTrue()
+        ->and($request->rules())->toHaveKeys(['name', 'type', 'status', 'latitude', 'longitude', 'temperature_max', 'ownership_type', 'capacity', 'attributes']);
+
+    $update = UpdateTrailerRequest::create('/v1/trailers/trailer_one', 'PATCH');
+    $update->setLaravelSession($request->session());
+    app()->instance('request', $update);
+    expect($update->authorize())->toBeTrue()
+        ->and($update->rules())->toHaveKey('name');
+});
+
+test('trailer filter executes text numeric state relationship and date branches', function () {
+    $connection = fleetOpsTrailerSupportDatabase();
+    $connection->table('vehicles')->insert(['uuid' => 'vehicle-filter', 'public_id' => 'vehicle_public', 'company_uuid' => 'company-trailer-support']);
+    $connection->getSchemaBuilder()->create('vendors', function ($table) {
+        $table->increments('id');
+        foreach (['uuid', 'public_id', 'company_uuid', 'name', '_key'] as $column) {
+            $table->string($column)->nullable();
+        }
+        $table->timestamps();
+        $table->softDeletes();
+    });
+    $connection->table('vendors')->insert(['uuid' => 'vendor-filter', 'public_id' => 'vendor_public', 'company_uuid' => 'company-trailer-support']);
+    $connection->getSchemaBuilder()->create('categories', function ($table) {
+        $table->increments('id');
+        foreach (['uuid', 'public_id', 'company_uuid', 'owner_uuid', 'owner_type', 'name', 'for', '_key'] as $column) {
+            $table->string($column)->nullable();
+        }
+        $table->timestamps();
+        $table->softDeletes();
+    });
+    $connection->table('categories')->insert(['uuid' => 'category-filter', 'public_id' => 'category_public', 'company_uuid' => 'company-trailer-support']);
+
+    Carbon::setTestNow('2026-09-03 12:00:00');
+    $builder = new FleetOpsTrailerFilterBuilder();
+    $filter  = fleetOpsTrailerFilter($builder);
+    $filter->queryForInternal();
+    $filter->queryForPublic();
+    $filter->query('needle');
+    $filter->publicId('trailer_public');
+    $filter->name('Trailer');
+    $filter->code('T-1');
+    $filter->trailerType('reefer');
+    $filter->status('available');
+    $filter->trailerMake('Acme');
+    $filter->trailerModel('ColdBox');
+    $filter->trailerYear('2026');
+    $filter->plateNumber('PLATE');
+    $filter->vin('VIN');
+    $filter->serialNumber('SERIAL');
+    $filter->length('12');
+    $filter->axleCount('3');
+    $filter->gvwr('30000');
+    $filter->payloadCapacity('20000');
+    $filter->ownershipType('owned');
+    $filter->devicesCount('2');
+    $filter->equipmentCount('1');
+    foreach (['never_connected', 'online', 'recently_offline', 'offline', 'unknown'] as $state) {
+        $filter->connectivityStatus($state);
+    }
+    $filter->attachmentState('attached');
+    $filter->attachmentState('detached');
+    $filter->vehicle('vehicle_public');
+    $filter->vehicle('missing_vehicle');
+    $filter->vendor('vendor_public');
+    $filter->device('device_public');
+    $filter->createdAt('2026-09-03');
+    $filter->updatedAt(['2026-09-01', '2026-09-03']);
+    $filter->lastOnlineAt('2026-09-03');
+    $filter->purchasedAt('2026-09-03');
+    $filter->bodyType('van');
+    $filter->refrigerated('true');
+    $filter->category('category_public');
+
+    // Console multi-option filters submit arrays; empty and mixed selections are safe.
+    $filter->trailerType(['reefer', 'flatbed']);
+    $filter->status([]);
+    $filter->status(['', 'available']);
+    $filter->connectivityStatus(['online', 'offline']);
+    $filter->connectivityStatus([]);
+    $filter->attachmentState(['attached', 'detached']);
+    $filter->attachmentState('');
+    $filter->vehicle([]);
+
+    expect($builder->called('search'))->toBeTrue()
+        ->and($builder->called('searchWhere'))->toBeTrue()
+        ->and($builder->called('whereNull'))->toBeTrue()
+        ->and($builder->called('whereBetween'))->toBeTrue()
+        ->and($builder->called('whereHas'))->toBeTrue()
+        ->and($builder->called('whereDoesntHave'))->toBeTrue()
+        ->and($builder->called('whereIn'))->toBeTrue()
+        ->and($builder->called('whereDate'))->toBeTrue()
+        ->and(collect($builder->calls)->contains(fn ($call) => $call[0] === 'whereIn' && $call[1] === 'type' && $call[2] === ['reefer', 'flatbed']))->toBeTrue()
+        ->and(collect($builder->calls)->contains(fn ($call) => $call[0] === 'where' && $call[1] === 'status' && $call[2] === 'available'))->toBeTrue()
+        ->and(collect($builder->calls)->contains(fn ($call) => $call[0] === 'whereIn' && $call[1] === 'category_uuid' && $call[2] === ['category-filter']))->toBeTrue()
+        ->and(collect($builder->calls)->contains(fn ($call) => $call[0] === 'whereIn' && $call[1] === 'connector_uuid' && $call[2] === ['vehicle-filter']))->toBeTrue()
+        ->and(collect($builder->calls)->contains(fn ($call) => $call[0] === 'whereHas' && $call[1] === 'devices'))->toBeTrue();
+
+    // Public requests never resolve relations by UUID; the console does.
+    $public = fleetOpsTrailerFilter($publicBuilder = new FleetOpsTrailerFilterBuilder());
+    $public->vehicle('vehicle-filter');
+    $internal = fleetOpsTrailerFilter($internalBuilder = new FleetOpsTrailerFilterBuilder(), [], true);
+    $internal->vehicle('vehicle-filter');
+    expect(collect($publicBuilder->calls)->contains(fn ($call) => $call[0] === 'whereIn' && $call[1] === 'connector_uuid' && $call[2] === []))->toBeTrue()
+        ->and(collect($internalBuilder->calls)->contains(fn ($call) => $call[0] === 'whereIn' && $call[1] === 'connector_uuid' && $call[2] === ['vehicle-filter']))->toBeTrue();
+    Carbon::setTestNow();
+});
+
+test('equipment filters cover attachment state type aliases and public targets', function () {
+    $connection = fleetOpsTrailerSupportDatabase();
+    $connection->getSchemaBuilder()->create('drivers', function ($table) {
+        $table->increments('id');
+        foreach (['uuid', 'public_id', 'internal_id', 'company_uuid', 'user_uuid', 'name', '_key'] as $column) {
+            $table->string($column)->nullable();
+        }
+        $table->timestamps();
+        $table->softDeletes();
+    });
+    // The Driver model scopes itself to drivers whose user still exists.
+    $connection->getSchemaBuilder()->create('users', function ($table) {
+        $table->increments('id');
+        foreach (['uuid', 'public_id', 'company_uuid', 'name', 'email', '_key'] as $column) {
+            $table->string($column)->nullable();
+        }
+        $table->timestamps();
+        $table->softDeletes();
+    });
+    $connection->table('users')->insert(['uuid' => 'user-equipable', 'company_uuid' => 'company-trailer-support', 'name' => 'Dana']);
+    $connection->table('drivers')->insert(['uuid' => 'driver-equipable', 'public_id' => 'driver_equipable', 'user_uuid' => 'user-equipable', 'company_uuid' => 'company-trailer-support']);
+    $connection->table('vehicles')->insert(['uuid' => 'vehicle-equipable', 'public_id' => 'vehicle_equipable', 'company_uuid' => 'company-trailer-support']);
+    $connection->table('assets')->insert(['uuid' => 'trailer-equipable', 'public_id' => 'trailer_public', 'company_uuid' => 'company-trailer-support', 'asset_class' => 'trailer', 'name' => 'Trailer']);
+    $builder         = new FleetOpsTrailerFilterBuilder();
+    $filter          = fleetOpsTrailerFilter($builder);
+    $request         = Request::create('/int/v1/equipment');
+    $request->setRouteResolver(fn () => new FleetOpsTrailerSupportRoute('int/v1/equipment'));
+    $request->setLaravelSession(app('session.store'));
+    $equipmentFilter = new EquipmentFilter($request);
+    $reflection      = new ReflectionClass($equipmentFilter);
+    $property        = $reflection->getParentClass()->getProperty('builder');
+    $property->setAccessible(true);
+    $property->setValue($equipmentFilter, $builder);
+
+    $equipmentFilter->attachmentState('attached');
+    $equipmentFilter->attachmentState('detached');
+    foreach (['vehicle', 'fleet-ops:vehicle', 'trailer', 'fleet-ops:trailer', 'unknown'] as $type) {
+        $equipmentFilter->equipableType($type);
+    }
+    $equipmentFilter->equipable('trailer_public');
+    $equipmentFilter->equipable('vehicle-equipable');
+    $equipmentFilter->equipable(['trailer_public', 'vehicle_equipable']);
+    $equipmentFilter->equipable('driver_equipable');
+    $equipmentFilter->equipable('');
+    expect($builder->called('whereNotNull'))->toBeTrue()
+        ->and($builder->called('whereNull'))->toBeTrue()
+        ->and($builder->called('whereRaw'))->toBeTrue()
+        ->and(collect($builder->calls)->contains(fn ($call) => $call[0] === 'whereIn' && $call[1] === 'equipable_uuid' && $call[2] === ['trailer-equipable']))->toBeTrue()
+        ->and(collect($builder->calls)->contains(fn ($call) => $call[0] === 'whereIn' && $call[1] === 'equipable_uuid' && $call[2] === ['vehicle-equipable']))->toBeTrue()
+        ->and(collect($builder->calls)->contains(fn ($call) => $call[0] === 'whereIn' && $call[1] === 'equipable_uuid' && sort($call[2]) && $call[2] === ['trailer-equipable', 'vehicle-equipable']))->toBeTrue()
+        ->and(collect($builder->calls)->contains(fn ($call) => $call[0] === 'whereIn' && $call[1] === 'equipable_uuid' && $call[2] === ['driver-equipable']))->toBeTrue();
+
+    // Public requests only resolve public ids, never UUIDs.
+    $publicBuilder = new FleetOpsTrailerFilterBuilder();
+    $publicRequest = Request::create('/v1/equipment');
+    $publicRequest->setLaravelSession(app('session.store'));
+    $publicFilter  = new EquipmentFilter($publicRequest);
+    $property->setValue($publicFilter, $publicBuilder);
+    $publicFilter->equipable('vehicle-equipable');
+    expect(collect($publicBuilder->calls)->contains(fn ($call) => $call[0] === 'whereIn' && $call[1] === 'equipable_uuid' && $call[2] === []))->toBeTrue();
+});
+
+test('trailer import validates rows and export scopes and maps spreadsheet data', function () {
+    $connection = fleetOpsTrailerSupportDatabase();
+    $import     = new TrailerImport();
+    $import->collection(collect([
+        new Collection([]),
+        new Collection(['name' => 'Cold Trailer', 'type' => 'reefer', 'status' => 'available', 'ignored' => 'value']),
+    ]));
+    expect($import->imported)->toBe(1)
+        ->and($connection->table('assets')->value('asset_class'))->toBe('trailer');
+
+    expect(fn () => (new TrailerImport())->collection(collect([['type' => 'reefer']])))->toThrow(ValidationException::class)
+        ->and(fn () => (new TrailerImport())->collection(collect([['name' => 'Bad', 'type' => 'spaceship']])))->toThrow(ValidationException::class);
+
+    $trailer = Trailer::withoutGlobalScopes()->first();
+    $trailer->forceFill(['public_id' => 'trailer_export', 'refrigerated' => true]);
+    $export = new TrailerExport([$trailer->uuid]);
+    expect($export->headings())->toContain('Plate Number')
+        ->and($export->map($trailer))->toContain('Yes')
+        ->and($export->collection())->toHaveCount(1)
+        ->and((new TrailerExport())->collection())->toHaveCount(1);
+});
+
+test('trailer and connection resources serialize loaded public relationships', function () {
+    fleetOpsTrailerSupportDatabase();
+    $vehicle = new Vehicle();
+    $vehicle->forceFill(['uuid' => 'vehicle-resource', 'public_id' => 'vehicle_public', 'name' => 'Road Tractor', 'plate_number' => 'TRUCK']);
+    $trailer = new Trailer();
+    $trailer->setAppends([]);
+    $trailer->forceFill(['uuid' => 'trailer-resource', 'public_id' => 'trailer_public', 'company_uuid' => 'company-trailer-support', 'name' => 'Reefer', 'type' => 'reefer', 'status' => 'available', 'last_online_at' => now(), 'telematics' => ['last_provider' => 'flespi', 'last_device_uuid' => 'device-uuid']]);
+    $connection = new AssetConnection(['relationship_type' => 'towing', 'position' => 1, 'connected_at' => now(), 'source' => 'manual']);
+    $connection->forceFill(['uuid' => 'connection-resource', 'public_id' => 'connection_public', 'connector_uuid' => 'vehicle-resource', 'connected_uuid' => 'trailer-resource', 'connector_type' => Vehicle::class, 'connected_type' => Trailer::class]);
+    $connection->setRelation('vehicle', $vehicle);
+    $connection->setRelation('trailer', $trailer);
+    $trailer->setRelation('currentConnection', $connection);
+    $trailer->setRelation('connections', collect([$connection]));
+    $trailer->setRelation('devices', collect([new Device()]));
+    $trailer->setRelation('equipments', collect([new Equipment()]));
+    $trailer->setRelation('positions', collect());
+
+    $request = Request::create('/v1/trailers/trailer_public');
+    app()->instance('request', $request);
+    $serialized = (new TrailerResource($trailer))->resolve($request);
+    $connected  = (new AssetConnectionResource($connection))->resolve($request);
+    expect($serialized['current_vehicle'])->toBe(['id' => 'vehicle_public', 'name' => 'Road Tractor', 'plate_number' => 'TRUCK'])
+        ->and($serialized['vehicle_id'])->toBe('vehicle_public')
+        ->and($serialized['current_vehicle_name'])->toBe('Road Tractor')
+        ->and($serialized['connections'])->not->toBeNull()
+        ->and($serialized['devices'])->not->toBeNull()
+        ->and($serialized['equipment'])->not->toBeNull()
+        ->and($serialized)->not->toHaveKeys(['equipments', 'uuid', 'category_name'])
+        ->and($serialized['telematics'])->toBe(['last_provider' => 'flespi'])
+        ->and($connected['vehicle'])->toBe(['id' => 'vehicle_public', 'name' => 'Road Tractor', 'plate_number' => 'TRUCK'])
+        ->and($connected['trailer'])->toBe(['id' => 'trailer_public', 'name' => 'Reefer', 'type' => 'reefer', 'plate_number' => null])
+        ->and($connected['vehicle_id'])->toBe('vehicle_public')
+        ->and($connected['active'])->toBeTrue();
+
+    // The console receives fully embedded models and internal identifiers.
+    $internalRequest = Request::create('/int/v1/trailers/trailer-resource');
+    $internalRequest->setRouteResolver(fn () => new FleetOpsTrailerSupportRoute('int/v1/trailers/{id}'));
+    app()->instance('request', $internalRequest);
+    $internal           = (new TrailerResource($trailer))->toArray($internalRequest);
+    $internalConnection = (new AssetConnectionResource($connection))->toArray($internalRequest);
+    expect($internal['asset_class'])->toBe('trailer')
+        ->and($internal['uuid'])->toBe('trailer-resource')
+        ->and($internal['current_vehicle'])->toBeInstanceOf(Illuminate\Http\Resources\Json\JsonResource::class)
+        ->and($internal['telematics'])->toBe(['last_provider' => 'flespi', 'last_device_uuid' => 'device-uuid'])
+        ->and($internalConnection['uuid'])->toBe('connection-resource')
+        ->and($internalConnection['connected_type'])->toBe('fleet-ops:trailer')
+        ->and($internalConnection['vehicle'])->toBeInstanceOf(Illuminate\Http\Resources\Json\JsonResource::class)
+        ->and($internalConnection['trailer'])->toBeInstanceOf(Illuminate\Http\Resources\Json\JsonResource::class);
+
+    // A connection whose vehicle record is gone still serializes, with an empty vehicle side.
+    $orphan = new AssetConnection(['relationship_type' => 'towing', 'position' => 1, 'connected_at' => now()]);
+    $orphan->setRelation('vehicle', null);
+    $orphaned = new Trailer();
+    $orphaned->setAppends([]);
+    $orphaned->forceFill(['uuid' => 'trailer-orphan', 'public_id' => 'trailer_orphan', 'company_uuid' => 'company-trailer-support', 'name' => 'Orphan']);
+    $orphaned->setRelation('currentConnection', $orphan);
+    app()->instance('request', $request);
+    $orphanSerialized = (new TrailerResource($orphaned))->resolve($request);
+    expect($orphanSerialized['current_vehicle'])->toBeNull()
+        ->and($orphanSerialized['vehicle_id'])->toBeNull()
+        ->and($orphanSerialized['current_vehicle_name'])->toBeNull()
+        ->and($orphanSerialized)->not->toHaveKeys(['connections', 'devices', 'equipment'], 'unloaded collections are omitted from the public API');
+
+    // The console always receives the embedded collections, even when they were not loaded.
+    app()->instance('request', $internalRequest);
+    $orphanInternal = (new TrailerResource($orphaned))->resolve($internalRequest);
+    expect($orphanInternal['connections'])->toBe([])
+        ->and($orphanInternal['devices'])->toBe([])
+        ->and($orphanInternal['equipments'])->toBe([])
+        ->and($orphanInternal)->not->toHaveKey('equipment');
+
+    $emptyConnection = new AssetConnection(['disconnected_at' => now()]);
+    $emptyConnection->setRelation('vehicle', null);
+    $emptyConnection->setRelation('trailer', null);
+    $empty = (new AssetConnectionResource($emptyConnection))->toArray($request);
+    expect($empty['vehicle'])->toBeNull()
+        ->and($empty['trailer'])->toBeNull()
+        ->and($empty['active'])->toBeFalse();
+});
+
+test('connection and installation models expose every polymorphic relation', function () {
+    fleetOpsTrailerSupportDatabase();
+    $connection   = new AssetConnection();
+    $device       = new Device();
+    $installation = new DeviceInstallation();
+    expect($connection->connector())->toBeInstanceOf(MorphTo::class)
+        ->and($connection->connected())->toBeInstanceOf(MorphTo::class)
+        ->and($connection->vehicle())->toBeInstanceOf(BelongsTo::class)
+        ->and($connection->trailer())->toBeInstanceOf(BelongsTo::class)
+        ->and($device->installations())->toBeInstanceOf(HasMany::class)
+        ->and($installation->device())->toBeInstanceOf(BelongsTo::class)
+        ->and($installation->attachable())->toBeInstanceOf(MorphTo::class);
+});
+
+test('asset model uses the spatial query builder for location updates', function () {
+    expect(class_uses_recursive(Asset::class))->toContain(SpatialTrait::class);
+});
+
+test('device installation history closes active rows for attach and detach transitions', function () {
+    $connection = fleetOpsTrailerSupportDatabase();
+    app()->instance('db.schema', $connection->getSchemaBuilder());
+    $connection->table('device_installations')->insert(['uuid' => 'installation-old', 'company_uuid' => 'company-trailer-support', 'device_uuid' => 'device-history', 'active_device_uuid' => 'device-history', 'installed_at' => now()]);
+    $device = new FleetOpsTrailerHistoryDevice();
+    $device->forceFill(['uuid' => 'device-history', 'company_uuid' => 'company-trailer-support']);
+    $trailer = new Trailer();
+    $trailer->forceFill(['uuid' => 'trailer-history', 'company_uuid' => 'company-trailer-support', 'name' => 'History Trailer']);
+
+    $idempotent = new FleetOpsTrailerHistoryDevice();
+    $idempotent->forceFill(['uuid' => 'device-idempotent', 'company_uuid' => 'company-trailer-support', 'attachable_type' => Trailer::class, 'attachable_uuid' => 'trailer-history']);
+    $foreignTrailer = new Trailer();
+    $foreignTrailer->forceFill(['uuid' => 'trailer-foreign', 'company_uuid' => 'company-other']);
+
+    expect($idempotent->attachTo($trailer))->toBeTrue()
+        ->and(fn () => $device->attachTo($foreignTrailer))->toThrow(DomainException::class)
+        ->and($device->attachTo($trailer))->toBeFalse()
+        ->and($connection->table('device_installations')->count())->toBe(2)
+        ->and($connection->table('device_installations')->where('uuid', 'installation-old')->value('removed_at'))->not->toBeNull()
+        ->and($device->detach())->toBeFalse()
+        ->and($connection->table('device_installations')->whereNull('removed_at')->count())->toBe(0);
+});
+
+test('device installation migration supports the base model soft delete scope', function () {
+    $migration = file_get_contents(__DIR__ . '/../migrations/2026_09_03_000003_create_device_installations_table.php');
+
+    expect($migration)->toContain('$table->softDeletes()');
+});
+
+test('search controller maps first class trailers into navigation results', function () {
+    $connection = fleetOpsTrailerSupportDatabase();
+    $connection->table('assets')->insert(['uuid' => 'trailer-search', 'public_id' => 'trailer_search', 'company_uuid' => 'company-trailer-support', 'name' => 'Search Reefer', 'description' => 'Cold', 'type' => 'reefer', 'asset_class' => 'trailer', 'status' => 'available', 'plate_number' => 'COLD-1']);
+    $controller = new SearchController();
+    $method     = new ReflectionMethod($controller, 'searchTrailers');
+    $method->setAccessible(true);
+    $results  = $method->invoke($controller, 'Search', 5);
+    $dispatch = new ReflectionMethod($controller, 'searchType');
+    $dispatch->setAccessible(true);
+    expect($results)->toHaveCount(1)
+        ->and($results->first())->toMatchArray(['label' => 'Search Reefer', 'type' => 'Trailer', 'route' => 'console.fleet-ops.management.trailers.index.details'])
+        ->and($dispatch->invoke($controller, 'trailers', 'Search', 5))->toHaveCount(1);
+});

package/server/tests/Unit/Http/Resources/IndexVehicleResourceTest.php

@@ -21,6 +21,11 @@ class FleetOpsIndexVehicleResourceProbe extends IndexVehicleResource
         return $this->compactDevices();
     }
 
+    public function compactTrailersForTest(): array
+    {
+        return $this->compactTrailers();
+    }
+
     public function locationCoordinatesForTest(): ?string
     {
         return $this->locationCoordinates();
@@ -147,9 +152,39 @@ test('index vehicle resource helper methods resolve devices and position labels'
         ],
     ]));
 
+    $vehicle->setRelation('currentTrailers', new Collection([
+        (object) [
+            'uuid'                => 'trailer-uuid',
+            'public_id'           => 'trailer_public',
+            'name'                => 'Reefer 12',
+            'display_name'        => 'Reefer 12',
+            'type'                => 'reefer',
+            'plate_number'        => 'TRL-12',
+            'status'              => 'in_use',
+            'connectivity_status' => 'online',
+            'online'              => 1,
+        ],
+    ]));
+
     $resource = new FleetOpsIndexVehicleResourceProbe($vehicle);
     fleetopsIndexVehicleResourceRequest(true);
 
+    expect($resource->compactTrailersForTest())->toBe([
+        [
+            'id'                  => 'trailer-uuid',
+            'uuid'                => 'trailer-uuid',
+            'public_id'           => 'trailer_public',
+            'name'                => 'Reefer 12',
+            'display_name'        => 'Reefer 12',
+            'type'                => 'reefer',
+            'plate_number'        => 'TRL-12',
+            'status'              => 'in_use',
+            'attachment_state'    => 'attached',
+            'connectivity_status' => 'online',
+            'online'              => true,
+        ],
+    ]);
+
     expect($resource->compactDevicesForTest())->toBe([
         [
             'id'            => 'device-uuid',

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

@@ -15,6 +15,7 @@ if (!function_exists('Fleetbase\FleetOps\Models\activity')) {
 use Fleetbase\FleetOps\Models\Driver;
 use Fleetbase\FleetOps\Models\Equipment;
 use Fleetbase\FleetOps\Models\Maintenance;
+use Fleetbase\FleetOps\Models\Trailer;
 use Fleetbase\FleetOps\Models\Vehicle;
 use Fleetbase\FleetOps\Models\Warranty;
 use Fleetbase\FleetOps\Support\Utils;
@@ -270,6 +271,27 @@ test('equipment mutators and appended accessors normalize assignment state', fun
         ->and($equipment->getReplacementCostEstimate())->toBeNull();
 });
 
+test('equipment assignment supports first class trailers without changing vehicle compatibility', function () {
+    $trailer = new Trailer();
+    $trailer->forceFill(['uuid' => 'trailer-uuid', 'name' => 'Reefer 7']);
+
+    $trailerEquipment = new Equipment([
+        'equipable_type' => 'fleet-ops:trailer',
+        'equipable_uuid' => 'trailer-uuid',
+    ]);
+    $trailerEquipment->setRelation('equipable', $trailer);
+
+    $vehicleEquipment = new Equipment([
+        'equipable_type' => 'fleet-ops:vehicle',
+        'equipable_uuid' => 'vehicle-uuid',
+    ]);
+
+    expect($trailerEquipment->equipable_type)->toBe(Utils::getMutationType('fleet-ops:trailer'))
+        ->and($trailerEquipment->equipped_to_name)->toBe('Reefer 7')
+        ->and($trailerEquipment->is_equipped)->toBeTrue()
+        ->and($vehicleEquipment->equipable_type)->toBe(Utils::getMutationType('fleet-ops:vehicle'));
+});
+
 test('equipment query scopes add expected filters', function () {
     $equipment = new Equipment();
     $query     = new FleetOpsEquipmentQueryFake();

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

@@ -3,6 +3,7 @@
 use Fleetbase\FleetOps\Models\Driver;
 use Fleetbase\FleetOps\Models\Equipment;
 use Fleetbase\FleetOps\Models\TrackingNumber;
+use Fleetbase\FleetOps\Models\Trailer;
 use Fleetbase\FleetOps\Models\Vehicle;
 use Fleetbase\FleetOps\Models\VehicleDevice;
 use Illuminate\Database\ConnectionResolver;
@@ -114,16 +115,19 @@ test('vehicle devices fall back to a direct vehicle lookup by uuid', function ()
         ->and($seen)->toBe(['vehicle_lookupone']);
 });
 
-test('unrecognised equipable types are stored verbatim', function () {
+test('known equipable aliases are normalized and unrecognised 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');
+    expect($equipment->getAttributes()['equipable_type'])->toBe(Trailer::class);
+
+    // Anything else is kept as given rather than silently dropped
+    $equipment->equipable_type = 'cargo-bay';
+    expect($equipment->getAttributes()['equipable_type'])->toBe('cargo-bay');
 });
 
 test('tracking number generation redraws when the first number is already taken', function () {