@fleetbase/fleetops-engine 0.6.58 → 0.6.59

package/server/tests/Unit/Console/SimulateGeofenceEventsCommandTest.php

@@ -0,0 +1,232 @@
+<?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\FleetOps\Console\Commands\event')) {
+    eval('namespace Fleetbase\FleetOps\Console\Commands; function event($event = null, $payload = []) { $GLOBALS["fleetopsSimulateGeofenceEvents"][] = $event; return []; }');
+}
+
+use Fleetbase\FleetOps\Console\Commands\SimulateGeofenceEvents;
+use Fleetbase\FleetOps\Models\Zone;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+/**
+ * Covers the fleetops:simulate-geofence-events command against SQLite:
+ * event parsing including sequences and invalid values, subject and
+ * geofence resolution by public id and uuid, state table and column
+ * mapping, the full simulation loop marking inside/outside states and
+ * dispatching entered, dwelled and exited events with dwell math, sleep
+ * pacing, and the failure branches for invalid arguments.
+ */
+class FleetOpsSimulateGeofenceZone extends Zone
+{
+    protected $table = 'zones';
+
+    public function getLatitudeAttribute(): float
+    {
+        return 1.30;
+    }
+
+    public function getLongitudeAttribute(): float
+    {
+        return 103.80;
+    }
+}
+
+class FleetOpsSimulateGeofenceProbe extends SimulateGeofenceEvents
+{
+    public array $arguments = [];
+    public array $options   = [];
+    public array $messages  = [];
+
+    public function __construct(array $arguments = [], array $options = [])
+    {
+        parent::__construct();
+        $this->arguments = $arguments;
+        $this->options   = $options;
+    }
+
+    public function argument($key = null)
+    {
+        return $this->arguments[$key] ?? null;
+    }
+
+    public function option($key = null)
+    {
+        return $this->options[$key] ?? null;
+    }
+
+    public function info($string, $verbosity = null)
+    {
+        $this->messages[] = ['info', $string];
+    }
+
+    public function line($string, $style = null, $verbosity = null)
+    {
+        $this->messages[] = ['line', $string];
+    }
+
+    public function error($string, $verbosity = null)
+    {
+        $this->messages[] = ['error', $string];
+    }
+
+    public function newLine($count = 1)
+    {
+        $this->messages[] = ['newline', $count];
+
+        return $this;
+    }
+
+    protected function resolveGeofence(string $identifier): array
+    {
+        // The real Zone location accessor requires the GEOS extension, so
+        // the full-run probe hydrates a coordinate-stubbed zone instead
+        $zone = FleetOpsSimulateGeofenceZone::withoutGlobalScopes()->where('public_id', $identifier)->first();
+
+        return $zone ? ['zone', $zone] : [null, null];
+    }
+
+    public function callHelper(string $method, ...$arguments): mixed
+    {
+        $reflection = new ReflectionMethod(SimulateGeofenceEvents::class, $method);
+        $reflection->setAccessible(true);
+
+        return $reflection->invoke($this, ...$arguments);
+    }
+}
+
+function fleetopsSimulateGeofenceBoot(): 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();
+    $tables = [
+        'drivers'       => ['uuid', 'public_id', 'company_uuid', 'user_uuid', 'vehicle_uuid', 'location', 'online'],
+        'vehicles'      => ['uuid', 'public_id', 'company_uuid', 'name', 'location', 'online'],
+        'zones'         => ['uuid', 'public_id', 'company_uuid', 'service_area_uuid', 'name', 'border'],
+        'service_areas' => ['uuid', 'public_id', 'company_uuid', 'name', 'border', 'type'],
+        'users'         => ['uuid', 'public_id', 'company_uuid', 'name', 'type'],
+    ];
+    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();
+        });
+    }
+    foreach (['driver_geofence_states' => 'driver_uuid', 'vehicle_geofence_states' => 'vehicle_uuid'] as $table => $column) {
+        $schema->create($table, function ($blueprint) use ($column) {
+            $blueprint->increments('id');
+            foreach ([$column, 'geofence_uuid', 'geofence_type', 'entered_at', 'exited_at', 'dwell_job_id'] as $col) {
+                $blueprint->string($col)->nullable();
+            }
+            $blueprint->integer('is_inside')->nullable();
+            $blueprint->timestamps();
+            $blueprint->unique([$column, 'geofence_uuid']);
+        });
+    }
+
+    session(['company' => 'company-1']);
+
+    return $connection;
+}
+
+test('events subjects geofences and state mappings resolve', function () {
+    $connection = fleetopsSimulateGeofenceBoot();
+    $connection->table('drivers')->insert(['uuid' => '11111111-1111-4111-8111-111111111111', 'public_id' => 'driver_simgeo11', 'company_uuid' => 'company-1']);
+    $connection->table('vehicles')->insert(['uuid' => '22222222-2222-4222-8222-222222222222', 'public_id' => 'vehicle_simgeo22', 'company_uuid' => 'company-1']);
+    $connection->table('zones')->insert(['uuid' => '33333333-3333-4333-8333-333333333333', 'public_id' => 'zone_simgeo333', 'company_uuid' => 'company-1']);
+    $connection->table('service_areas')->insert(['uuid' => '44444444-4444-4444-8444-444444444444', 'public_id' => 'sa_simgeo4444', 'company_uuid' => 'company-1']);
+
+    $probe = new FleetOpsSimulateGeofenceProbe();
+
+    expect($probe->callHelper('parseEvents', 'sequence'))->toBe(['entered', 'dwelled', 'exited'])
+        ->and($probe->callHelper('parseEvents', 'entered, exited, bogus'))->toBe(['entered', 'exited'])
+        ->and($probe->callHelper('parseEvents', 'bogus'))->toBe([]);
+
+    expect($probe->callHelper('resolveSubject', 'driver_simgeo11')[1]?->uuid)->toBe('11111111-1111-4111-8111-111111111111')
+        ->and($probe->callHelper('resolveSubject', 'vehicle_simgeo22')[0])->toBe('vehicle')
+        ->and($probe->callHelper('resolveSubject', '11111111-1111-4111-8111-111111111111')[0])->toBe('driver')
+        ->and($probe->callHelper('resolveSubject', '22222222-2222-4222-8222-222222222222')[0])->toBe('vehicle')
+        ->and($probe->callHelper('resolveSubject', 'unknown')[0])->toBeNull();
+
+    $resolveGeofence = new ReflectionMethod(SimulateGeofenceEvents::class, 'resolveGeofence');
+    $resolveGeofence->setAccessible(true);
+    $command = new SimulateGeofenceEvents();
+    expect($resolveGeofence->invoke($command, 'zone_simgeo333')[0])->toBe('zone')
+        ->and($resolveGeofence->invoke($command, 'sa_simgeo4444')[0])->toBe('service_area')
+        ->and($resolveGeofence->invoke($command, '33333333-3333-4333-8333-333333333333')[0])->toBe('zone')
+        ->and($resolveGeofence->invoke($command, '44444444-4444-4444-8444-444444444444')[0])->toBe('service_area')
+        ->and($resolveGeofence->invoke($command, 'nothing')[0])->toBeNull();
+
+    expect($probe->callHelper('stateTable', 'vehicle'))->toBe('vehicle_geofence_states')
+        ->and($probe->callHelper('stateTable', 'driver'))->toBe('driver_geofence_states')
+        ->and($probe->callHelper('subjectColumn', 'vehicle'))->toBe('vehicle_uuid')
+        ->and($probe->callHelper('subjectColumn', 'driver'))->toBe('driver_uuid');
+});
+
+test('the simulation loop marks states and dispatches the event sequence', function () {
+    $connection = fleetopsSimulateGeofenceBoot();
+    $connection->table('drivers')->insert(['uuid' => '11111111-1111-4111-8111-111111111111', 'public_id' => 'driver_simrun11', 'company_uuid' => 'company-1']);
+    $connection->table('zones')->insert(['uuid' => '33333333-3333-4333-8333-333333333333', 'public_id' => 'zone_simrun333', 'company_uuid' => 'company-1']);
+
+    $GLOBALS['fleetopsSimulateGeofenceEvents'] = [];
+    $probe                                     = new FleetOpsSimulateGeofenceProbe(
+        ['events' => 'sequence', 'subject' => 'driver_simrun11', 'geofence' => 'zone_simrun333'],
+        ['repeat' => 1, 'sleep' => 0, 'dwell-minutes' => 5, 'no-log' => false, 'reset-state' => true]
+    );
+
+    expect($probe->handle())->toBe(0)
+        ->and($GLOBALS['fleetopsSimulateGeofenceEvents'])->toHaveCount(3)
+        ->and((int) $connection->table('driver_geofence_states')->value('is_inside'))->toBe(0)
+        ->and($connection->table('driver_geofence_states')->value('exited_at'))->not->toBeNull();
+});
+
+test('sleep pacing applies and invalid arguments fail fast', function () {
+    $connection = fleetopsSimulateGeofenceBoot();
+    $connection->table('drivers')->insert(['uuid' => '11111111-1111-4111-8111-111111111111', 'public_id' => 'driver_simerr11', 'company_uuid' => 'company-1']);
+    $connection->table('zones')->insert(['uuid' => '33333333-3333-4333-8333-333333333333', 'public_id' => 'zone_simerr333', 'company_uuid' => 'company-1']);
+
+    // A one-second pacing pass through a single event covers the sleep branch
+    $paced = new FleetOpsSimulateGeofenceProbe(
+        ['events' => 'entered', 'subject' => 'driver_simerr11', 'geofence' => 'zone_simerr333'],
+        ['repeat' => 1, 'sleep' => 1, 'dwell-minutes' => 5, 'no-log' => true, 'reset-state' => false]
+    );
+    expect($paced->handle())->toBe(0);
+
+    $invalidEvents = new FleetOpsSimulateGeofenceProbe(['events' => 'bogus', 'subject' => 'x', 'geofence' => 'y'], ['repeat' => 1, 'sleep' => 0, 'dwell-minutes' => 5]);
+    expect($invalidEvents->handle())->toBe(1);
+
+    $missingSubject = new FleetOpsSimulateGeofenceProbe(['events' => 'entered', 'subject' => 'driver_missing99', 'geofence' => 'zone_simerr333'], ['repeat' => 1, 'sleep' => 0, 'dwell-minutes' => 5]);
+    expect($missingSubject->handle())->toBe(1);
+
+    $missingGeofence = new FleetOpsSimulateGeofenceProbe(['events' => 'entered', 'subject' => 'driver_simerr11', 'geofence' => 'zone_missing99'], ['repeat' => 1, 'sleep' => 0, 'dwell-minutes' => 5]);
+    expect($missingGeofence->handle())->toBe(1);
+});

package/server/tests/Unit/Console/SyncTelematicsCommandTest.php

@@ -0,0 +1,136 @@
+<?php
+
+use Fleetbase\FleetOps\Console\Commands\SyncTelematics;
+use Fleetbase\FleetOps\Contracts\TelematicProviderDescriptor;
+use Fleetbase\FleetOps\Support\Telematics\TelematicProviderRegistry;
+use Fleetbase\TestSupport\DispatchRecorder;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+/**
+ * Covers the fleetops:sync-telematics command with the process lock skipped:
+ * pollable-provider filtering by request/discovery/webhook flags, the
+ * no-provider early exit, and the chunked job queueing over active
+ * telematics connections.
+ */
+class FleetOpsSyncTelematicsProbe extends SyncTelematics
+{
+    public array $messages = [];
+    public array $options  = ['no-lock' => true, 'provider' => [], 'limit' => 500, 'exclude-webhook-providers' => false];
+
+    public function info($string, $verbosity = null)
+    {
+        $this->messages[] = ['info', $string];
+    }
+
+    public function warn($string, $verbosity = null)
+    {
+        $this->messages[] = ['warn', $string];
+    }
+
+    public function option($key = null, $default = null)
+    {
+        return $this->options[$key] ?? $default;
+    }
+}
+
+function fleetopsSyncTelematicsRegistry(array $descriptors): TelematicProviderRegistry
+{
+    $registry = new TelematicProviderRegistry();
+    foreach ($descriptors as $descriptor) {
+        $registry->register(new TelematicProviderDescriptor($descriptor));
+    }
+
+    return $registry;
+}
+
+function fleetopsSyncTelematicsBoot(): 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();
+    $schema->create('telematics', function ($blueprint) {
+        $blueprint->increments('id');
+        foreach (['uuid', 'public_id', 'company_uuid', 'provider', 'status', 'credentials', 'name'] as $column) {
+            $blueprint->string($column)->nullable();
+        }
+        $blueprint->timestamps();
+        $blueprint->timestamp('deleted_at')->nullable();
+    });
+
+    DispatchRecorder::$dispatched = [];
+
+    return $connection;
+}
+
+test('sync telematics exits early without pollable providers', function () {
+    fleetopsSyncTelematicsBoot();
+
+    $command  = new FleetOpsSyncTelematicsProbe();
+    $registry = fleetopsSyncTelematicsRegistry([
+        ['key' => 'webhook-only', 'label' => 'Webhook Only', 'supports_discovery' => false],
+    ]);
+
+    expect($command->handle($registry))->toBe(0)
+        ->and($command->messages)->toContain(['info', 'No pollable telematics providers found.']);
+});
+
+test('sync telematics queues jobs for active matching connections', function () {
+    $connection = fleetopsSyncTelematicsBoot();
+    $connection->table('telematics')->insert([
+        ['uuid' => 'tm-1', 'company_uuid' => 'company-1', 'provider' => 'traccar', 'status' => 'active'],
+        ['uuid' => 'tm-2', 'company_uuid' => 'company-1', 'provider' => 'traccar', 'status' => 'connected'],
+        ['uuid' => 'tm-3', 'company_uuid' => 'company-1', 'provider' => 'traccar', 'status' => 'disabled'],
+        ['uuid' => 'tm-4', 'company_uuid' => null, 'provider' => 'traccar', 'status' => 'active'],
+        ['uuid' => 'tm-5', 'company_uuid' => 'company-1', 'provider' => 'other', 'status' => 'active'],
+    ]);
+
+    $command  = new FleetOpsSyncTelematicsProbe();
+    $registry = fleetopsSyncTelematicsRegistry([
+        ['key' => 'traccar', 'label' => 'Traccar', 'supports_discovery' => true],
+    ]);
+
+    expect($command->handle($registry))->toBe(0)
+        ->and(DispatchRecorder::$dispatched)->toHaveCount(2)
+        ->and($command->messages)->toContain(['info', 'Queued 2 telematics sync job(s).']);
+});
+
+test('sync telematics filters providers by request and webhook flags', function () {
+    fleetopsSyncTelematicsBoot();
+
+    $command          = new FleetOpsSyncTelematicsProbe();
+    $command->options = array_merge($command->options, [
+        'provider'                  => ['traccar'],
+        'exclude-webhook-providers' => true,
+    ]);
+
+    $registry = fleetopsSyncTelematicsRegistry([
+        ['key' => 'traccar', 'label' => 'Traccar', 'supports_discovery' => true, 'supports_webhooks' => true],
+        ['key' => 'samsara', 'label' => 'Samsara', 'supports_discovery' => true],
+    ]);
+
+    // traccar is requested but excluded for webhook support; samsara is
+    // pollable but not requested — nothing remains.
+    expect($command->handle($registry))->toBe(0)
+        ->and($command->messages)->toContain(['info', 'No pollable telematics providers found.']);
+});

package/server/tests/Unit/Constraints/HOSConstraintTest.php

@@ -0,0 +1,158 @@
+<?php
+
+if (!function_exists('Fleetbase\Traits\config')) {
+    eval('namespace Fleetbase\Traits; function config($key = null, $default = null) { return $key === "api.cache.enabled" ? false : $default; }');
+}
+
+use Fleetbase\FleetOps\Constraints\HOSConstraint;
+use Fleetbase\Models\ScheduleItem;
+use Illuminate\Support\Carbon;
+
+class FleetOpsUnitHosScheduleItemFake extends ScheduleItem
+{
+    public int $duration;
+    public string $start_at;
+    public ?string $end_at         = null;
+    public ?string $break_start_at = null;
+    public ?string $break_end_at   = null;
+}
+
+class FleetOpsUnitHosConstraintProbe extends HOSConstraint
+{
+    public $recentItems;
+    public ?Carbon $lastOffDutyPeriod = null;
+
+    protected function getRecentScheduleItems(ScheduleItem $item)
+    {
+        return $this->recentItems ?? collect();
+    }
+
+    protected function getLastOffDutyPeriod(ScheduleItem $item, $recentItems, int $hours): ?Carbon
+    {
+        return $this->lastOffDutyPeriod;
+    }
+}
+
+function fleetopsUnitHosScheduleItem(array $attributes): ScheduleItem
+{
+    $item = new FleetOpsUnitHosScheduleItemFake();
+
+    foreach ($attributes as $key => $value) {
+        $item->{$key} = $value;
+    }
+
+    return $item;
+}
+
+function fleetopsUnitHosRecentItem(array $attributes): object
+{
+    return (object) $attributes;
+}
+
+test('hos constraint validation passes when schedule item remains inside all limits', function () {
+    $constraint              = new FleetOpsUnitHosConstraintProbe();
+    $constraint->recentItems = collect([
+        fleetopsUnitHosRecentItem([
+            'duration'       => 120,
+            'start_at'       => '2026-07-18 08:00:00',
+            'break_start_at' => null,
+            'break_end_at'   => null,
+        ]),
+        fleetopsUnitHosRecentItem([
+            'duration'       => 180,
+            'start_at'       => '2026-07-19 08:00:00',
+            'break_start_at' => null,
+            'break_end_at'   => null,
+        ]),
+    ]);
+
+    $result = $constraint->validate(fleetopsUnitHosScheduleItem([
+        'id'             => 22,
+        'assignee_uuid'  => 'driver-1',
+        'assignee_type'  => 'driver',
+        'duration'       => 60,
+        'start_at'       => '2026-07-19 12:00:00',
+        'end_at'         => '2026-07-19 13:00:00',
+        'break_start_at' => null,
+        'break_end_at'   => null,
+    ]));
+
+    expect($result->passed())->toBeTrue()
+        ->and($result->failed())->toBeFalse()
+        ->and($result->getViolations())->toBe([]);
+});
+
+test('hos constraint validation returns every violation when limits are exceeded', function () {
+    $constraint                    = new FleetOpsUnitHosConstraintProbe();
+    $constraint->lastOffDutyPeriod = Carbon::parse('2026-07-19 00:00:00');
+    $constraint->recentItems       = collect([
+        fleetopsUnitHosRecentItem([
+            'duration'       => 4200,
+            'start_at'       => '2026-07-18 08:00:00',
+            'break_start_at' => null,
+            'break_end_at'   => null,
+        ]),
+        fleetopsUnitHosRecentItem([
+            'duration'       => 600,
+            'start_at'       => '2026-07-19 03:00:00',
+            'break_start_at' => null,
+            'break_end_at'   => null,
+        ]),
+    ]);
+
+    $result = $constraint->validate(fleetopsUnitHosScheduleItem([
+        'id'             => 23,
+        'assignee_uuid'  => 'driver-1',
+        'assignee_type'  => 'driver',
+        'duration'       => 120,
+        'start_at'       => '2026-07-19 13:30:00',
+        'end_at'         => '2026-07-19 15:30:00',
+        'break_start_at' => null,
+        'break_end_at'   => null,
+    ]));
+
+    expect($result->failed())->toBeTrue()
+        ->and(collect($result->getViolations())->pluck('constraint_key')->all())->toBe([
+            'hos_11_hour_driving_limit',
+            'hos_14_hour_duty_window',
+            'hos_60_70_hour_weekly_limit',
+            'hos_30_minute_break',
+        ])
+        ->and(collect($result->getViolations())->pluck('severity')->all())->toBe([
+            'critical',
+            'critical',
+            'critical',
+            'warning',
+        ]);
+});
+
+test('recent schedule items query scopes assignee and rolling window', function () {
+    $connection = new Illuminate\Database\SQLiteConnection(new PDO('sqlite::memory:'));
+    $resolver   = new Illuminate\Database\ConnectionResolver(['default' => $connection, 'mysql' => $connection]);
+    $resolver->setDefaultConnection('mysql');
+    Illuminate\Database\Eloquent\Model::setConnectionResolver($resolver);
+    $schema = $connection->getSchemaBuilder();
+    $schema->create('schedule_items', function ($blueprint) {
+        $blueprint->increments('id');
+        foreach (['uuid', 'public_id', 'company_uuid', 'schedule_uuid', 'assignee_type', 'assignee_uuid', 'status', 'start_at', 'end_at', '_key'] as $column) {
+            $blueprint->string($column)->nullable();
+        }
+        $blueprint->timestamps();
+        $blueprint->timestamp('deleted_at')->nullable();
+    });
+    $connection->table('schedule_items')->insert([
+        ['uuid' => 'shift-hos-current', 'assignee_type' => 'driver', 'assignee_uuid' => 'driver-hos-1', 'start_at' => '2026-07-27 08:00:00', 'end_at' => '2026-07-27 16:00:00'],
+        ['uuid' => 'shift-hos-recent', 'assignee_type' => 'driver', 'assignee_uuid' => 'driver-hos-1', 'start_at' => '2026-07-25 08:00:00', 'end_at' => '2026-07-25 16:00:00'],
+        ['uuid' => 'shift-hos-old', 'assignee_type' => 'driver', 'assignee_uuid' => 'driver-hos-1', 'start_at' => '2026-07-01 08:00:00', 'end_at' => '2026-07-01 16:00:00'],
+        ['uuid' => 'shift-hos-other', 'assignee_type' => 'driver', 'assignee_uuid' => 'driver-hos-2', 'start_at' => '2026-07-26 08:00:00', 'end_at' => '2026-07-26 16:00:00'],
+    ]);
+
+    $current    = ScheduleItem::where('uuid', 'shift-hos-current')->first();
+    $constraint = new HOSConstraint();
+    $reflection = new ReflectionMethod(HOSConstraint::class, 'getRecentScheduleItems');
+    $reflection->setAccessible(true);
+    $recent = $reflection->invoke($constraint, $current);
+
+    expect($recent)->toHaveCount(1)
+        ->and($recent->first()->uuid)->toBe('shift-hos-recent');
+});

package/server/tests/Unit/Events/EventModelRecordTest.php

@@ -0,0 +1,93 @@
+<?php
+
+use Fleetbase\FleetOps\Flow\Activity;
+use Fleetbase\FleetOps\Models\Entity;
+use Fleetbase\FleetOps\Models\Waypoint;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+/**
+ * Covers getModelRecord() on the entity and waypoint activity events: each
+ * resolves the order that owns the subject's payload.
+ */
+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); }');
+}
+
+function fleetopsEventRecordBoot(): 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');
+
+    $connection->getSchemaBuilder()->create('orders', function ($blueprint) {
+        $blueprint->increments('id');
+        foreach (['uuid', 'public_id', 'company_uuid', 'payload_uuid', 'status'] as $column) {
+            $blueprint->string($column)->nullable();
+        }
+        $blueprint->timestamps();
+        $blueprint->timestamp('deleted_at')->nullable();
+    });
+
+    session(['company' => 'company-event-1']);
+    $connection->table('orders')->insert([
+        ['uuid' => 'order-event-1', 'company_uuid' => 'company-event-1', 'payload_uuid' => 'payload-event-1'],
+        ['uuid' => 'order-event-2', 'company_uuid' => 'company-event-1', 'payload_uuid' => 'payload-event-2'],
+    ]);
+
+    return $connection;
+}
+
+function fleetopsEventActivity(): Activity
+{
+    return new Activity(['key' => 'order_started', 'code' => 'started', 'status' => 'Started', 'details' => 'Started'], []);
+}
+
+test('entity activity events resolve the order owning the payload', function (string $eventClass) {
+    fleetopsEventRecordBoot();
+
+    $entity = new Entity();
+    $entity->setRawAttributes(['uuid' => 'entity-event-1', 'payload_uuid' => 'payload-event-1'], true);
+
+    $event = new $eventClass($entity, fleetopsEventActivity());
+    expect($event->getModelRecord()?->uuid)->toBe('order-event-1');
+
+    // An entity on another payload resolves that payload's order
+    $other = new Entity();
+    $other->setRawAttributes(['uuid' => 'entity-event-2', 'payload_uuid' => 'payload-event-2'], true);
+    expect((new $eventClass($other, fleetopsEventActivity()))->getModelRecord()?->uuid)->toBe('order-event-2');
+})->with([
+    'activity changed' => [Fleetbase\FleetOps\Events\EntityActivityChanged::class],
+    'completed'        => [Fleetbase\FleetOps\Events\EntityCompleted::class],
+]);
+
+test('waypoint activity events resolve the order owning the payload', function (string $eventClass) {
+    fleetopsEventRecordBoot();
+
+    $waypoint = new Waypoint();
+    $waypoint->setRawAttributes(['uuid' => 'waypoint-event-1', 'payload_uuid' => 'payload-event-1'], true);
+
+    $event = new $eventClass($waypoint, fleetopsEventActivity());
+    expect($event->getModelRecord()?->uuid)->toBe('order-event-1');
+})->with([
+    'activity changed' => [Fleetbase\FleetOps\Events\WaypointActivityChanged::class],
+    'completed'        => [Fleetbase\FleetOps\Events\WaypointCompleted::class],
+]);

package/server/tests/Unit/Events/OrderDispatchFailedTest.php

@@ -0,0 +1,34 @@
+<?php
+
+use Fleetbase\FleetOps\Events\OrderDispatchFailed;
+use Fleetbase\FleetOps\Models\Order;
+use Illuminate\Support\Str;
+
+class FleetOpsOrderDispatchFailedUnitProbe extends OrderDispatchFailed
+{
+    public function getEventData(): array
+    {
+        return [];
+    }
+}
+
+test('order dispatch failed event stores dispatch reason and lifecycle identity', function () {
+    if (!Str::hasMacro('humanize')) {
+        Str::macro('humanize', fn (string $value): string => str_replace('_', ' ', Str::snake($value)));
+    }
+
+    $order = new Order();
+    $order->setRawAttributes([
+        'uuid'      => 'order-dispatch-failed',
+        'public_id' => 'order_public',
+    ], true);
+
+    $event = new FleetOpsOrderDispatchFailedUnitProbe($order, 'no_driver_available');
+
+    expect($event->eventName)->toBe('dispatch_failed')
+        ->and($event->getReason())->toBe('no_driver_available')
+        ->and($event->reason)->toBe('no_driver_available')
+        ->and($event->modelUuid)->toBe('order-dispatch-failed')
+        ->and($event->modelName)->toBe('order')
+        ->and($event->broadcastAs())->toBe('order.dispatch_failed');
+});