@fleetbase/fleetops-engine 0.6.63 → 0.6.65

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 () {

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

@@ -0,0 +1,204 @@
+<?php
+
+use Fleetbase\FleetOps\Events\TrailerLocationChanged;
+use Fleetbase\FleetOps\Models\AssetConnection;
+use Fleetbase\FleetOps\Models\Device;
+use Fleetbase\FleetOps\Models\Equipment;
+use Fleetbase\FleetOps\Models\Maintenance;
+use Fleetbase\FleetOps\Models\MaintenanceSchedule;
+use Fleetbase\FleetOps\Models\Position;
+use Fleetbase\FleetOps\Models\Trailer;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Models\WorkOrder;
+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\HasManyThrough;
+use Illuminate\Database\Eloquent\Relations\HasOne;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Support\Carbon;
+
+// Model identifier hooks bind to the dispatcher present when the class boots.
+if (!EloquentModel::getEventDispatcher()) {
+    EloquentModel::setEventDispatcher(new Illuminate\Events\Dispatcher());
+}
+
+function fleetOpsTrailerUseInMemoryConnection(): 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);
+    $connection->statement('create table assets (
+        id integer primary key autoincrement,
+        uuid varchar(64),
+        public_id varchar(64) null unique,
+        company_uuid varchar(64),
+        name varchar(255),
+        code varchar(64) null,
+        type varchar(64) null,
+        asset_class varchar(64) null,
+        status varchar(64) null,
+        slug varchar(255) null,
+        last_online_at datetime null,
+        created_at datetime null,
+        updated_at datetime null,
+        deleted_at datetime null
+    )');
+    $connection->statement('create table positions (
+        id integer primary key autoincrement,
+        uuid varchar(64), public_id varchar(64), company_uuid varchar(64),
+        subject_uuid varchar(64), subject_type varchar(255), destination_uuid varchar(64),
+        coordinates text, heading varchar(64), bearing varchar(64), speed varchar(64), altitude varchar(64),
+        created_at datetime null, updated_at datetime null, deleted_at datetime null
+    )');
+
+    $resolver = new ConnectionResolver(['default' => $connection, 'mysql' => $connection]);
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+    app()->instance('responsecache', new class {
+        public function __call($method, $arguments)
+        {
+            return null;
+        }
+    });
+
+    return $connection;
+}
+
+test('trailer creation enforces its discriminator defaults and public id namespace', function () {
+    fleetOpsTrailerUseInMemoryConnection();
+
+    $trailer = new Trailer([
+        'company_uuid'  => 'company-a',
+        'name'          => 'Reefer 12',
+        'asset_class'   => 'vehicle',
+    ]);
+    Trailer::getEventDispatcher()->until('eloquent.creating: ' . Trailer::class, $trailer);
+
+    expect($trailer->asset_class)->toBe(Trailer::ASSET_CLASS)
+        ->and($trailer->status)->toBe('available')
+        ->and($trailer->public_id)->toStartWith('trailer_')
+        ->and($trailer->uuid)->not->toBeEmpty();
+
+    EloquentModel::unsetEventDispatcher();
+});
+
+test('trailer global scope never returns another asset class', function () {
+    $connection = fleetOpsTrailerUseInMemoryConnection();
+    $connection->table('assets')->insert([
+        ['uuid' => 'trailer-uuid', 'public_id' => 'trailer_public', 'company_uuid' => 'company-a', 'name' => 'Trailer', 'asset_class' => 'trailer', 'status' => 'available'],
+        ['uuid' => 'vehicle-uuid', 'public_id' => 'asset_public', 'company_uuid' => 'company-a', 'name' => 'Vehicle-like asset', 'asset_class' => 'vehicle', 'status' => 'available'],
+    ]);
+
+    expect(Trailer::query()->pluck('uuid')->all())->toBe(['trailer-uuid'])
+        ->and(Trailer::query()->toSql())->toContain('asset_class');
+});
+
+test('trailer exposes first class connection device equipment maintenance and position relations', function () {
+    fleetOpsTrailerUseInMemoryConnection();
+    $trailer = new Trailer();
+
+    expect($trailer->currentConnection())->toBeInstanceOf(HasOne::class)
+        ->and($trailer->currentConnection()->getRelated())->toBeInstanceOf(AssetConnection::class)
+        ->and($trailer->connections())->toBeInstanceOf(HasMany::class)
+        ->and($trailer->devices()->getRelated())->toBeInstanceOf(Device::class)
+        ->and($trailer->equipments()->getRelated())->toBeInstanceOf(Equipment::class)
+        ->and($trailer->positions()->getRelated())->toBeInstanceOf(Position::class)
+        ->and($trailer->maintenances()->getRelated())->toBeInstanceOf(Maintenance::class)
+        ->and($trailer->maintenanceSchedules()->getRelated())->toBeInstanceOf(MaintenanceSchedule::class)
+        ->and($trailer->workOrders()->getRelated())->toBeInstanceOf(WorkOrder::class);
+});
+
+test('asset connections preserve effective dated vehicle and trailer identities', function () {
+    fleetOpsTrailerUseInMemoryConnection();
+    $connection = new AssetConnection([
+        'relationship_type' => 'towing',
+        'position'          => 2,
+        'connected_at'      => '2026-09-03 12:00:00',
+        'disconnected_at'   => null,
+    ]);
+
+    expect($connection->vehicle())->toBeInstanceOf(BelongsTo::class)
+        ->and($connection->vehicle()->getRelated())->toBeInstanceOf(Vehicle::class)
+        ->and($connection->trailer())->toBeInstanceOf(BelongsTo::class)
+        ->and($connection->trailer()->getRelated())->toBeInstanceOf(Trailer::class)
+        ->and($connection->relationship_type)->toBe('towing')
+        ->and($connection->position)->toBe(2)
+        ->and($connection->disconnected_at)->toBeNull();
+});
+
+test('vehicles expose current and historical trailer relationships', function () {
+    fleetOpsTrailerUseInMemoryConnection();
+    $vehicle = new Vehicle();
+
+    expect($vehicle->trailerConnections())->toBeInstanceOf(HasMany::class)
+        ->and($vehicle->trailerConnections()->getRelated())->toBeInstanceOf(AssetConnection::class)
+        ->and($vehicle->currentTrailers())->toBeInstanceOf(HasManyThrough::class)
+        ->and($vehicle->currentTrailers()->getRelated())->toBeInstanceOf(Trailer::class);
+});
+
+test('trailer connectivity is distinct from lifecycle and attachment state', function () {
+    Carbon::setTestNow('2026-09-03 12:00:00');
+
+    $trailer = new Trailer(['status' => 'maintenance']);
+    expect($trailer->connectivity_status)->toBe('never_connected')
+        ->and($trailer->status)->toBe('maintenance')
+        ->and($trailer->attachment_state)->toBe('detached');
+
+    $vehicle    = new Vehicle();
+    $connection = new AssetConnection();
+    $connection->setRelation('vehicle', $vehicle);
+    $trailer->setRelation('currentConnection', $connection);
+    expect($trailer->current_vehicle)->toBe($vehicle)
+        ->and($trailer->attachment_state)->toBe('attached');
+
+    $trailer->last_online_at = Carbon::now()->subMinutes(5);
+    expect($trailer->connectivity_status)->toBe('online');
+
+    $trailer->last_online_at = Carbon::now()->subHours(2);
+    expect($trailer->connectivity_status)->toBe('recently_offline');
+
+    $trailer->last_online_at = Carbon::now()->subDays(2);
+    expect($trailer->connectivity_status)->toBe('offline');
+
+    Carbon::setTestNow();
+});
+
+test('trailer positions require coordinates and preserve model or scalar destinations', function () {
+    fleetOpsTrailerUseInMemoryConnection();
+    $trailer = new Trailer();
+    $trailer->forceFill(['uuid' => 'trailer-position', 'company_uuid' => 'company-a']);
+    expect($trailer->createPosition())->toBeNull();
+
+    $vehicle = new Vehicle();
+    $vehicle->forceFill(['uuid' => 'vehicle-destination']);
+    $fromModel  = $trailer->createPosition(['latitude' => 1.3, 'longitude' => 103.8, 'heading' => 90, 'bearing' => 91, 'speed' => 40, 'altitude' => 12], $vehicle);
+    $fromScalar = $trailer->createPosition(['latitude' => 1.4, 'longitude' => 103.9], 'place-destination');
+    expect($fromModel)->toBeInstanceOf(Position::class)
+        ->and($fromModel->destination_uuid)->toBe('vehicle-destination')
+        ->and($fromScalar->destination_uuid)->toBe('place-destination');
+});
+
+test('trailer location broadcasts use tenant and trailer channels without exposing internal ids', function () {
+    Carbon::setTestNow('2026-09-03 12:00:00');
+
+    $trailer = new Trailer();
+    $trailer->forceFill([
+        'uuid'         => 'internal-trailer-uuid',
+        'public_id'    => 'trailer_public',
+        'company_uuid' => 'company-a',
+        'speed'        => 42,
+        'heading'      => 180,
+    ]);
+    $event = new TrailerLocationChanged($trailer, ['source' => 'telematics']);
+
+    expect(array_map(fn ($channel) => $channel->name, $event->broadcastOn()))
+        ->toBe(['company.company-a', 'trailer.trailer_public', 'trailer.internal-trailer-uuid'])
+        ->and($event->broadcastWith()['data']['id'])->toBe('trailer_public')
+        ->and($event->broadcastWith()['data'])->not->toHaveKey('uuid')
+        ->and($event->broadcastWith()['data']['additionalData'])->toBe(['source' => 'telematics']);
+
+    Carbon::setTestNow();
+});

package/server/tests/Unit/Support/Telematics/TelematicServiceTelemetryTest.php

@@ -6,6 +6,7 @@ use Fleetbase\FleetOps\Models\DeviceEvent;
 use Fleetbase\FleetOps\Models\Position;
 use Fleetbase\FleetOps\Models\Sensor;
 use Fleetbase\FleetOps\Models\Telematic;
+use Fleetbase\FleetOps\Models\Trailer;
 use Fleetbase\FleetOps\Models\Vehicle;
 use Fleetbase\FleetOps\Support\Telematics\TelematicProviderRegistry;
 use Fleetbase\FleetOps\Support\Telematics\TelematicService;
@@ -105,6 +106,36 @@ class FleetOpsTelematicServiceTelemetryVehicleFake extends Vehicle
     }
 }
 
+class FleetOpsTelematicServiceTelemetryTrailerFake extends Trailer
+{
+    public int $saveCount = 0;
+
+    public function __construct(array $attributes = [])
+    {
+        $this->attributes = $attributes;
+    }
+
+    public function getAttribute($key)
+    {
+        return $this->attributes[$key] ?? null;
+    }
+
+    public function setAttribute($key, $value)
+    {
+        $this->attributes[$key] = $value;
+
+        return $this;
+    }
+
+    public function save(array $options = [])
+    {
+        $this->saveCount++;
+        $this->exists = true;
+
+        return true;
+    }
+}
+
 class FleetOpsTelematicServiceTelemetryProviderFake implements TelematicProviderInterface
 {
     public array $normalizedSensors = [];
@@ -317,6 +348,68 @@ test('telematic service skips event positions and vehicle updates when event loc
         ->and($GLOBALS['fleetops_telematic_service_broadcasts'])->toBe([]);
 });
 
+test('telematic service updates trailer telemetry and rejects stale trailer snapshots', function () {
+    Carbon::setTestNow(Carbon::parse('2026-09-03 12:00:00'));
+    $GLOBALS['fleetops_telematic_service_broadcasts'] = [];
+
+    $service = new FleetOpsTelematicServiceTelemetryServiceFake();
+    $trailer = new FleetOpsTelematicServiceTelemetryTrailerFake([
+        'uuid'         => 'trailer-uuid',
+        'public_id'    => 'trailer_public',
+        'company_uuid' => 'company-uuid',
+        'telematics'   => ['last_event_at' => '2026-09-03T11:00:00.000000Z'],
+    ]);
+    $device = new FleetOpsTelematicServiceTelemetryDeviceFake(['uuid' => 'device-uuid', 'device_id' => 'device-1']);
+    $device->setRelation('attachable', $trailer);
+    $event = new FleetOpsTelematicServiceTelemetryEventFake([
+        'uuid'        => 'event-new',
+        'public_id'   => 'event_new',
+        'device_uuid' => 'device-uuid',
+        'event_type'  => 'telemetry_update',
+        'provider'    => 'samsara',
+        'occurred_at' => Carbon::parse('2026-09-03 11:30:00'),
+    ]);
+
+    fleetOpsTelematicServiceTelemetryInvoke($service, 'applyDeviceEventTelemetry', [$event, [
+        'location'            => ['latitude' => 47.918, 'longitude' => 106.917],
+        'speed'               => 42,
+        'heading'             => 180,
+        'odometer'            => 32000,
+        'reefer_engine_hours' => 800,
+    ], $device, true, null]);
+
+    expect($trailer->saveCount)->toBe(1)
+        ->and($trailer->location)->toBeInstanceOf(SpatialPoint::class)
+        ->and($trailer->speed)->toBe(42)
+        ->and($trailer->heading)->toBe(180)
+        ->and($trailer->odometer)->toBe(32000)
+        ->and($trailer->reefer_engine_hours)->toBe(800)
+        ->and($trailer->telematics['last_event_uuid'])->toBe('event-new')
+        ->and($trailer->telematics['last_provider'])->toBe('samsara')
+        ->and($GLOBALS['fleetops_telematic_service_broadcasts'])->toHaveCount(1);
+
+    $staleEvent = new FleetOpsTelematicServiceTelemetryEventFake([
+        'uuid'        => 'event-stale',
+        'public_id'   => 'event_stale',
+        'device_uuid' => 'device-uuid',
+        'event_type'  => 'telemetry_update',
+        'provider'    => 'samsara',
+        'occurred_at' => Carbon::parse('2026-09-03 10:30:00'),
+    ]);
+
+    fleetOpsTelematicServiceTelemetryInvoke($service, 'applyDeviceEventTelemetry', [$staleEvent, [
+        'location' => ['latitude' => 1, 'longitude' => 1],
+        'speed'    => 5,
+    ], $device, true, null]);
+
+    expect($trailer->saveCount)->toBe(1)
+        ->and($trailer->speed)->toBe(42)
+        ->and($trailer->telematics['last_event_uuid'])->toBe('event-new')
+        ->and($GLOBALS['fleetops_telematic_service_broadcasts'])->toHaveCount(1);
+
+    Carbon::setTestNow();
+});
+
 test('telematic service stores list snapshot sensors and skips provider failures', function () {
     $service   = new FleetOpsTelematicServiceTelemetryServiceFake();
     $provider  = new FleetOpsTelematicServiceTelemetryProviderFake();

package/server/tests/VehicleControllerHelperContractsTest.php

@@ -1,5 +1,6 @@
 <?php
 
+use Fleetbase\FleetOps\Exceptions\DeviceAlreadyAttachedException;
 use Fleetbase\FleetOps\Http\Controllers\Internal\v1\VehicleController;
 use Fleetbase\FleetOps\Models\Device;
 use Fleetbase\FleetOps\Models\Driver;
@@ -485,4 +486,17 @@ test('vehicle controller reports detach lookup failures and attach exceptions',
     $response = $controller->attachDevice(new Request(['device' => 'device-public']), 'vehicle-public');
     expect($response->getData(true))->toBe(['error' => 'Unable to attach device to vehicle. Please try again or contact support.'])
         ->and($response->getStatusCode())->toBe(500);
+
+    // A device installed on another asset is a conflict the operator must resolve by detaching first
+    $controller          = new FleetOpsVehicleControllerProbe();
+    $controller->vehicle = new FleetOpsVehicleEndpointFake();
+    $controller->device  = new class extends FleetOpsVehicleDeviceFake {
+        public function attachTo(Fleetbase\Models\Model $attachable): bool
+        {
+            throw DeviceAlreadyAttachedException::for('Truck 2');
+        }
+    };
+    $response = $controller->attachDevice(new Request(['device' => 'device-public']), 'vehicle-public');
+    expect($response->getData(true))->toBe(['error' => 'Device is already attached to Truck 2. Detach it before attaching it elsewhere.'])
+        ->and($response->getStatusCode())->toBe(409);
 });

package/server/tests/VehicleResourceContractsTest.php

@@ -311,3 +311,42 @@ test('vehicle without driver resource omits driver relationships and serializes
         ])
         ->and($webhook)->not->toHaveKey('driver');
 });
+
+/**
+ * Resolve the request's `with` list the way a nested resource does.
+ *
+ * @return array<int, string>
+ */
+function fleetopsVehicleResourceRequestedRelations(mixed $resource, array $query): array
+{
+    $request = Request::create('/api/v1/fleet-ops/orders', 'GET', $query);
+    $method  = new ReflectionMethod(VehicleResource::class, 'requestedRelations');
+    $method->setAccessible(true);
+
+    return $method->invoke(new VehicleResource($resource), $request);
+}
+
+test('requested relations keep only what the wrapped model defines', function () {
+    $vehicle = new class(['uuid' => 'vehicle-uuid']) extends FleetOpsVehicleResourceFixture {
+        public function driver(): void
+        {
+        }
+    };
+
+    // Nested under an Order, the request's `with` describes the order:
+    // `payload` and `driverAssigned.vehicle` are not vehicle relations and must
+    // never reach this model's loader. The vehicle's own relations still pass,
+    // including a nested path whose root the vehicle defines.
+    expect(fleetopsVehicleResourceRequestedRelations($vehicle, ['with' => ['payload', 'driverAssigned.vehicle', 'driver', 'driver.user', '']]))->toBe(['driver', 'driver.user'])
+        ->and(fleetopsVehicleResourceRequestedRelations($vehicle, ['with' => 'payload,driver']))->toBe(['driver'])
+        ->and(fleetopsVehicleResourceRequestedRelations($vehicle, ['with' => ['.driver']]))->toBe([])
+        ->and(fleetopsVehicleResourceRequestedRelations($vehicle, []))->toBe([]);
+});
+
+test('requested relations are empty when the resource cannot load any', function () {
+    // Webhook fixtures and compact serializers hand the resource plain data;
+    // there is no loader to feed, so nothing is requested from it.
+    expect(fleetopsVehicleResourceRequestedRelations(['uuid' => 'vehicle-uuid'], ['with' => ['driver']]))->toBe([])
+        ->and(fleetopsVehicleResourceRequestedRelations((object) ['uuid' => 'vehicle-uuid'], ['with' => ['driver']]))->toBe([])
+        ->and(fleetopsVehicleResourceRequestedRelations(fleetopsVehicleResourceFixture(), ['with' => ['driver']]))->toBe([]);
+});