@fleetbase/fleetops-engine 0.6.70 → 0.6.72

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

@@ -0,0 +1,81 @@
+<?php
+
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\Tests\Support\TrackingPageDatabase;
+use Illuminate\Cache\ArrayStore;
+use Illuminate\Cache\Repository;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Support\Facades\Cache;
+
+beforeEach(function () {
+    Cache::swap(new Repository(new ArrayStore()));
+    session(['company' => 'co-1']);
+});
+
+afterEach(function () {
+    EloquentModel::unsetConnectionResolver();
+});
+
+function driverAssignVehicleDatabase(): SQLiteConnection
+{
+    $db = TrackingPageDatabase::boot();
+
+    $db->getSchemaBuilder()->create('users', function ($table) {
+        $table->increments('id');
+        $table->string('uuid')->nullable();
+        $table->string('company_uuid')->nullable();
+        $table->timestamps();
+        $table->softDeletes();
+    });
+    $db->getSchemaBuilder()->create('drivers', function ($table) {
+        $table->increments('id');
+        $table->string('uuid')->nullable();
+        $table->string('public_id')->nullable();
+        $table->string('company_uuid')->nullable();
+        $table->string('user_uuid')->nullable();
+        $table->string('vehicle_uuid')->nullable();
+        $table->timestamps();
+        $table->softDeletes();
+    });
+
+    foreach (['user-1', 'user-2'] as $user) {
+        TrackingPageDatabase::insert($db, 'users', ['uuid' => $user, 'company_uuid' => 'co-1']);
+    }
+    TrackingPageDatabase::insert($db, 'drivers', ['uuid' => 'driver-1', 'company_uuid' => 'co-1', 'user_uuid' => 'user-1', 'vehicle_uuid' => 'vehicle-1']);
+    TrackingPageDatabase::insert($db, 'drivers', ['uuid' => 'driver-2', 'company_uuid' => 'co-1', 'user_uuid' => 'user-2']);
+
+    return $db;
+}
+
+function driverAssignVehicleVehicle(): Vehicle
+{
+    $vehicle = new Vehicle();
+    $vehicle->setRawAttributes(['uuid' => 'vehicle-1', 'company_uuid' => 'co-1'], true);
+    $vehicle->exists = true;
+
+    return $vehicle;
+}
+
+function driverAssignVehicleAssignments(SQLiteConnection $db): array
+{
+    return $db->table('drivers')->orderBy('uuid')->pluck('vehicle_uuid', 'uuid')->all();
+}
+
+test('assigning a driver the vehicle it already has keeps the assignment', function () {
+    $db = driverAssignVehicleDatabase();
+
+    Driver::where('uuid', 'driver-1')->first()->assignVehicle(driverAssignVehicleVehicle());
+
+    expect(driverAssignVehicleAssignments($db))->toBe(['driver-1' => 'vehicle-1', 'driver-2' => null]);
+});
+
+test('assigning a vehicle to another driver moves it from its current driver', function () {
+    $db = driverAssignVehicleDatabase();
+
+    $driver = Driver::where('uuid', 'driver-2')->first()->assignVehicle(driverAssignVehicleVehicle());
+
+    expect(driverAssignVehicleAssignments($db))->toBe(['driver-1' => null, 'driver-2' => 'vehicle-1'])
+        ->and($driver->vehicle->uuid)->toBe('vehicle-1');
+});

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

@@ -33,7 +33,8 @@ use Illuminate\Database\SQLiteConnection;
 use Spatie\Activitylog\LogOptions;
 use Spatie\Sluggable\SlugOptions;
 
-class FleetOpsFleetUnitCountingRelationFake
+// Extends the relation the model method now declares, so the override stays compatible; the parent constructor is skipped on purpose.
+class FleetOpsFleetUnitCountingRelationFake extends HasManyThrough
 {
     public array $wheres = [];
 
@@ -59,7 +60,7 @@ class FleetOpsFleetUnitCountingFake extends Fleet
     public array $driverRelations  = [];
     public array $vehicleRelations = [];
 
-    public function drivers()
+    public function drivers(): HasManyThrough
     {
         $relation                = new FleetOpsFleetUnitCountingRelationFake(5);
         $this->driverRelations[] = $relation;
@@ -67,7 +68,7 @@ class FleetOpsFleetUnitCountingFake extends Fleet
         return $relation;
     }
 
-    public function vehicles()
+    public function vehicles(): HasManyThrough
     {
         $relation                 = new FleetOpsFleetUnitCountingRelationFake(8);
         $this->vehicleRelations[] = $relation;

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

@@ -0,0 +1,143 @@
+<?php
+
+if (!class_exists('FleetOpsOrderCancelReasonRecorder', false)) {
+    class FleetOpsOrderCancelReasonRecorder
+    {
+        public static array $events = [];
+
+        public static function dispatch($job): object
+        {
+            if ($job instanceof Closure) {
+                $job();
+            }
+
+            return new class {
+                public function afterCommit(): self
+                {
+                    return $this;
+                }
+            };
+        }
+    }
+}
+
+if (!function_exists('Fleetbase\FleetOps\Models\dispatch')) {
+    eval('namespace Fleetbase\FleetOps\Models; function dispatch($job) { return \FleetOpsOrderCancelReasonRecorder::dispatch($job); }');
+}
+
+if (!function_exists('Fleetbase\FleetOps\Models\event')) {
+    eval('namespace Fleetbase\FleetOps\Models; function event($event = null) { \FleetOpsOrderCancelReasonRecorder::$events[] = $event; return $event; }');
+}
+
+if (!class_exists('Fleetbase\FleetOps\Events\OrderCanceled', false)) {
+    eval('namespace Fleetbase\FleetOps\Events; class OrderCanceled { public $activity = null; public $waypoint = null; public function __construct(public $order) {} public function getModelRecord() { return $this->order; } }');
+}
+
+use Fleetbase\FleetOps\Events\OrderCanceled;
+use Fleetbase\FleetOps\Flow\Activity;
+use Fleetbase\FleetOps\Listeners\HandleOrderCanceled;
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Models\OrderConfig;
+
+/**
+ * Covers canceling an order with a reason: the reason becomes the canceled
+ * status details and rides on the OrderCanceled event, while the config's
+ * activity is left untouched and a plain cancel carries no activity.
+ */
+class FleetOpsOrderCancelReasonOrder extends Order
+{
+    public array $activities = [];
+
+    public function updateActivity(?Activity $activity = null, $proof = null): Order
+    {
+        $this->activities[] = $activity;
+        $this->status       = $activity?->code;
+
+        return $this;
+    }
+}
+
+class FleetOpsOrderCancelReasonConfig extends OrderConfig
+{
+    public ?Activity $canceled = null;
+
+    public function getCanceledActivity()
+    {
+        return $this->canceled;
+    }
+}
+
+function fleetopsOrderCancelReasonOrder(): array
+{
+    FleetOpsOrderCancelReasonRecorder::$events = [];
+
+    $config           = new FleetOpsOrderCancelReasonConfig();
+    $config->canceled = new Activity(['code' => 'canceled', 'status' => 'Order canceled', 'details' => 'Order was canceled']);
+
+    $order = new FleetOpsOrderCancelReasonOrder();
+    $order->setRawAttributes(['uuid' => 'order-uuid', 'status' => 'dispatched'], true);
+    $order->setRelation('orderConfig', $config);
+
+    return [$order, $config];
+}
+
+test('canceling with a reason records it as the canceled details and on the event', function () {
+    [$order, $config] = fleetopsOrderCancelReasonOrder();
+
+    $order->cancelWithReason('  Customer moved house  ');
+
+    $event = collect(FleetOpsOrderCancelReasonRecorder::$events)->first(fn ($event) => $event instanceof OrderCanceled);
+
+    expect($order->status)->toBe('canceled')
+        ->and($order->activities[0]->get('details'))->toBe('Customer moved house')
+        ->and($config->canceled->get('details'))->toBe('Order was canceled')
+        ->and($event)->not->toBeNull()
+        ->and($event->activity->get('details'))->toBe('Customer moved house');
+});
+
+test('a plain cancel keeps the config activity and sends no reason', function () {
+    [$order, $config] = fleetopsOrderCancelReasonOrder();
+
+    $order->cancel();
+
+    $event = collect(FleetOpsOrderCancelReasonRecorder::$events)->first(fn ($event) => $event instanceof OrderCanceled);
+
+    expect($order->activities[0])->toBe($config->canceled)
+        ->and($event->activity)->toBeNull();
+});
+
+test('the canceled listener passes the reason on to the assigned driver', function () {
+    [$order] = fleetopsOrderCancelReasonOrder();
+    $order->setRawAttributes(array_merge($order->getAttributes(), ['driver_assigned_uuid' => 'driver-uuid']));
+    $order->setRelation('facilitator', null);
+    $order->setRelation('trackingNumber', null);
+
+    $driver = new class extends Driver {
+        public array $notified = [];
+
+        public function notify($instance)
+        {
+            $this->notified[] = $instance;
+        }
+    };
+
+    $listener = new class($driver) extends HandleOrderCanceled {
+        public function __construct(private Driver $driverForTest)
+        {
+        }
+
+        protected function findAssignedDriver($order): ?Driver
+        {
+            return $this->driverForTest;
+        }
+    };
+
+    $event           = new OrderCanceled($order);
+    $event->activity = new Activity(['code' => 'canceled', 'details' => 'Customer moved house']);
+    $listener->handle($event);
+
+    expect($driver->notified)->toHaveCount(1)
+        ->and($driver->notified[0]->reason)->toBe('Customer moved house')
+        ->and($driver->notified[0]->data)->toBe(['id' => null, 'type' => 'order_canceled', 'reason' => 'Customer moved house']);
+});

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

@@ -240,6 +240,66 @@ test('distance and time setters use origin and destination positions', function
     expect($origin?->getLat())->toBe(1.20);
 });
 
+test('a driver without a reported location does not turn the order origin into null island', function () {
+    $connection = fleetopsOrderPayloadBoot();
+    // Sunshine -> Melton, Victoria: a ~25 km straight-line run
+    $connection->table('places')->insert([
+        ['uuid' => '11111111-1111-4111-8111-111111111111', 'public_id' => 'place_vicpickup', 'company_uuid' => 'company-1', 'location' => fleetopsOrderPayloadWkb(-37.78, 144.83)],
+        ['uuid' => '22222222-2222-4222-8222-222222222222', 'public_id' => 'place_vicdropoff', 'company_uuid' => 'company-1', 'location' => fleetopsOrderPayloadWkb(-37.68, 144.58)],
+    ]);
+    $connection->table('payloads')->insert(['uuid' => 'payload-1', 'company_uuid' => 'company-1', 'pickup_uuid' => '11111111-1111-4111-8111-111111111111', 'dropoff_uuid' => '22222222-2222-4222-8222-222222222222']);
+    $connection->table('users')->insert(['uuid' => 'user-1', 'company_uuid' => 'company-1', 'type' => 'user']);
+    // Drivers are created with a POINT(0 0) placeholder until their first location report
+    $connection->table('drivers')->insert(['uuid' => '44444444-4444-4444-8444-444444444444', 'public_id' => 'driver_vicnoloc', 'company_uuid' => 'company-1', 'user_uuid' => 'user-1', 'location' => fleetopsOrderPayloadWkb(0, 0)]);
+    $connection->table('orders')->insert(['uuid' => 'order-1', 'company_uuid' => 'company-1', 'payload_uuid' => 'payload-1', 'driver_assigned_uuid' => '44444444-4444-4444-8444-444444444444']);
+
+    $order  = Order::query()->where('uuid', 'order-1')->first();
+    $origin = $order->getCurrentOriginPosition();
+    expect($origin?->getLat())->toBe(-37.78)
+        ->and($origin?->getLng())->toBe(144.83);
+
+    $order->setPreliminaryDistanceAndTime();
+    $distance = (float) $connection->table('orders')->value('distance');
+    $time     = (float) $connection->table('orders')->value('time');
+    expect($distance)->toBeGreaterThan(20000)->toBeLessThan(30000)
+        ->and($time)->toBe(round($distance / 100) * 7.2);
+
+    $connection->table('orders')->where('uuid', 'order-1')->update(['distance' => null, 'time' => null]);
+    $order = Order::query()->where('uuid', 'order-1')->first();
+    $order->setDistanceAndTime(['provider' => 'calculate']);
+    expect((float) $connection->table('orders')->value('distance'))->toBe($distance)
+        ->and((float) $connection->table('orders')->value('time'))->toBe($time);
+
+    // Once the driver reports a real position it becomes the origin again
+    $connection->table('drivers')->update(['location' => fleetopsOrderPayloadWkb(-37.70, 144.70)]);
+    $order = Order::query()->where('uuid', 'order-1')->first();
+    expect($order->getCurrentOriginPosition()?->getLat())->toBe(-37.70);
+});
+
+test('distance setters leave the order untouched when an endpoint is an ungeocoded placeholder', function () {
+    $connection = fleetopsOrderPayloadBoot();
+    $connection->table('places')->insert([
+        ['uuid' => '11111111-1111-4111-8111-111111111111', 'public_id' => 'place_vicpickup', 'company_uuid' => 'company-1', 'location' => fleetopsOrderPayloadWkb(-37.78, 144.83)],
+        ['uuid' => '22222222-2222-4222-8222-222222222222', 'public_id' => 'place_ungeocoded', 'company_uuid' => 'company-1', 'location' => fleetopsOrderPayloadWkb(0, 0)],
+    ]);
+    $connection->table('payloads')->insert([
+        ['uuid' => 'payload-1', 'company_uuid' => 'company-1', 'pickup_uuid' => '11111111-1111-4111-8111-111111111111', 'dropoff_uuid' => '22222222-2222-4222-8222-222222222222'],
+        ['uuid' => 'payload-2', 'company_uuid' => 'company-1', 'pickup_uuid' => '22222222-2222-4222-8222-222222222222', 'dropoff_uuid' => '11111111-1111-4111-8111-111111111111'],
+    ]);
+    $connection->table('orders')->insert([
+        ['uuid' => 'order-1', 'company_uuid' => 'company-1', 'payload_uuid' => 'payload-1'],
+        ['uuid' => 'order-2', 'company_uuid' => 'company-1', 'payload_uuid' => 'payload-2'],
+    ]);
+
+    foreach (['order-1', 'order-2'] as $uuid) {
+        $order = Order::query()->where('uuid', $uuid)->first();
+        expect($order->setPreliminaryDistanceAndTime())->toBe($order)
+            ->and($order->setDistanceAndTime(['provider' => 'calculate']))->toBe($order)
+            ->and($connection->table('orders')->where('uuid', $uuid)->value('distance'))->toBeNull()
+            ->and($connection->table('orders')->where('uuid', $uuid)->value('time'))->toBeNull();
+    }
+});
+
 test('config resolution prefers uuid then company default', function () {
     $connection = fleetopsOrderPayloadBoot();
     $flow       = json_encode([

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

@@ -205,10 +205,12 @@ test('assign driver covers instance string and invalid identifier branches', fun
     expect($assigned->assignDriver($driver))->toBe($assigned)
         ->and($assigned->notified)->toBe([]);
 
-    // Driver instance assignment notifies and saves
+    // Driver instance assignment saves; the order observer sends the assignment
+    // notification after the save, so assignDriver does not send it as well
     $order->assignDriver($driver);
     expect($order->driver_assigned_uuid)->toBe('driver-1')
-        ->and($order->notified)->toBe(['driver-assigned'])
+        ->and($order->notified)->toBe([])
+        ->and($order->silentDriverAssignment)->toBeFalse()
         ->and($connection->table('orders')->value('driver_assigned_uuid'))->toBe('driver-1');
 
     // Public id resolution recurses into instance assignment

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

@@ -32,7 +32,8 @@ use Illuminate\Database\Eloquent\Relations\HasManyThrough;
 use Illuminate\Database\Eloquent\Relations\HasOne;
 use Illuminate\Database\SQLiteConnection;
 
-class FleetOpsPayloadUnitRelationCountFake
+// Extends the relation the model method now declares, so the override stays compatible; the parent constructor is skipped on purpose.
+class FleetOpsPayloadUnitRelationCountFake extends HasManyThrough
 {
     public function __construct(private readonly Payload $payload, private readonly string $relation)
     {
@@ -44,6 +45,19 @@ class FleetOpsPayloadUnitRelationCountFake
     }
 }
 
+// Extends the relation the model method now declares, so the override stays compatible; the parent constructor is skipped on purpose.
+class FleetOpsPayloadUnitEntityCountFake extends HasMany
+{
+    public function __construct(private readonly Payload $payload)
+    {
+    }
+
+    public function count(): int
+    {
+        return $this->payload->getRelation('entities')?->count() ?? 0;
+    }
+}
+
 class FleetOpsPayloadUnitDatabaseProbe
 {
     public function __construct(private SQLiteConnection $connection)
@@ -147,14 +161,14 @@ class FleetOpsPayloadUnitFake extends Payload
     public array $activityUpdates        = [];
     public array $currentWaypointWrites  = [];
 
-    public function waypoints()
+    public function waypoints(): HasManyThrough
     {
         return new FleetOpsPayloadUnitRelationCountFake($this, 'waypoints');
     }
 
-    public function entities()
+    public function entities(): HasMany
     {
-        return new FleetOpsPayloadUnitRelationCountFake($this, 'entities');
+        return new FleetOpsPayloadUnitEntityCountFake($this);
     }
 
     public function hasMeta($key): bool

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

@@ -92,12 +92,12 @@ class FleetOpsServicableRate extends ServiceRate
         return parent::getAttribute($key);
     }
 
-    public function rateFees()
+    public function rateFees(): Illuminate\Database\Eloquent\Relations\HasMany
     {
         return $this->hasMany(Fleetbase\FleetOps\Models\ServiceRateFee::class, 'service_rate_uuid', 'uuid');
     }
 
-    public function parcelFees()
+    public function parcelFees(): Illuminate\Database\Eloquent\Relations\HasMany
     {
         return $this->hasMany(Fleetbase\FleetOps\Models\ServiceRateParcelFee::class, 'service_rate_uuid', 'uuid');
     }

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

@@ -84,13 +84,21 @@ class FleetOpsTrackingNumberInsertFake extends TrackingNumber
 
 beforeEach(function () {
     FleetOpsTrackingNumberInsertFake::resetInsertFake();
+
+    $this->previousConsoleConfig = config('fleetbase.console');
+    config(['fleetbase.console' => ['host' => 'console.fleetbase.test', 'subdomain' => null, 'secure' => true]]);
+});
+
+afterEach(function () {
+    config(['fleetbase.console' => $this->previousConsoleConfig]);
 });
 
 test('tracking number insert filters values and creates initial owner status', function () {
     $owner = new Order();
     $owner->setRawAttributes([
-        'uuid'   => 'order-uuid',
-        'status' => 'pending',
+        'uuid'      => 'order-uuid',
+        'public_id' => 'order_public',
+        'status'    => 'pending',
     ], true);
 
     $uuid = FleetOpsTrackingNumberInsertFake::insertGetUuid([
@@ -114,8 +122,10 @@ test('tracking number insert filters values and creates initial owner status', f
         'owner_uuid'      => 'order-uuid',
         'owner_type'      => Utils::getMutationType($owner),
         'tracking_number' => 'TRACK-AE',
-        'qr_code'         => 'QRCODE:order-uuid',
-        'barcode'         => 'PDF417:order-uuid',
+        // The QR carries the tracking url naming the owner by public id, never its uuid;
+        // the barcode carries the bare tracking number printed beneath it.
+        'qr_code'         => 'QRCODE,M:https://console.fleetbase.test/~/track-order?order=TRACK-AE&r=order_public&v=1',
+        'barcode'         => 'C128:TRACK-AE',
         'meta'            => '{"source":"api"}',
     ])->and($inserted)->not->toHaveKey('not_allowed');
 
@@ -147,8 +157,8 @@ test('tracking number insert defaults region location and skips side effects whe
         ->and(FleetOpsTrackingNumberInsertFake::$insertedValues[0])->toMatchArray([
             'uuid'            => 'tracking-uuid',
             'tracking_number' => 'TRACK-SG',
-            'qr_code'         => 'QRCODE:',
-            'barcode'         => 'PDF417:',
+            'qr_code'         => 'QRCODE,M:https://console.fleetbase.test/~/track-order?order=TRACK-SG&v=1',
+            'barcode'         => 'C128:TRACK-SG',
         ])
         ->and(FleetOpsTrackingNumberInsertFake::$createdStatuses)->toBe([])
         ->and(FleetOpsTrackingNumberInsertFake::$statusUpdates)->toBe([])
@@ -197,3 +207,54 @@ test('tracking numbers generate unique values and resolve or fail lookups', func
         ->and(TrackingNumber::findTrackingOrFail('track_findone1')->uuid)->toBe('tn-find-1')
         ->and(fn () => TrackingNumber::findTrackingOrFail('missing-number'))->toThrow(Illuminate\Database\Eloquent\ModelNotFoundException::class);
 });
+
+test('tracking number insert takes the owner public id from callers without an owner model', function () {
+    // Waypoints and entities insert their owner with a raw query and pass only ids.
+    FleetOpsTrackingNumberInsertFake::insertGetUuid([
+        'owner_uuid'      => 'waypoint-uuid',
+        'owner_type'      => 'Fleetbase\\FleetOps\\Models\\Waypoint',
+        'owner_public_id' => 'waypoint_public',
+        'region'          => 'SG',
+    ]);
+
+    $inserted = FleetOpsTrackingNumberInsertFake::$insertedValues[0];
+
+    expect($inserted['qr_code'])->toBe('QRCODE,M:https://console.fleetbase.test/~/track-order?order=TRACK-SG&r=waypoint_public&v=1')
+        // A helper key, not a column: the fillable filter keeps it out of the insert.
+        ->and($inserted)->not->toHaveKey('owner_public_id')
+        ->and($inserted['owner_uuid'])->toBe('waypoint-uuid');
+});
+
+test('tracking number code images render a medium-correction QR and a Code 128 barcode', function () {
+    $calls = new ArrayObject();
+    foreach (['DNS2D', 'DNS1D'] as $facade) {
+        app()->instance($facade, new class($facade, $calls) {
+            public function __construct(private string $facade, private ArrayObject $calls)
+            {
+            }
+
+            public function getBarcodePNG(...$arguments)
+            {
+                $this->calls[] = array_merge([$this->facade], $arguments);
+
+                return $this->facade . '-png';
+            }
+        });
+        Illuminate\Support\Facades\Facade::clearResolvedInstance($facade);
+    }
+
+    try {
+        expect(TrackingNumber::codeImages('ACM1234567890SG', 'entity_public'))->toBe([
+            'qr_code' => 'DNS2D-png',
+            'barcode' => 'DNS1D-png',
+        ])->and($calls->getArrayCopy())->toBe([
+            ['DNS2D', 'https://console.fleetbase.test/~/track-order?order=ACM1234567890SG&r=entity_public&v=1', 'QRCODE,M'],
+            ['DNS1D', 'ACM1234567890SG', 'C128', 2, 60],
+        ]);
+    } finally {
+        foreach (['DNS2D', 'DNS1D'] as $facade) {
+            app()->forgetInstance($facade);
+            Illuminate\Support\Facades\Facade::clearResolvedInstance($facade);
+        }
+    }
+});

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

@@ -100,6 +100,17 @@ class FleetOpsVehicleModelFindResultFake
     {
     }
 
+    public function where($column, $operator = null): static
+    {
+        if (is_callable($column)) {
+            $column($this->query);
+        } else {
+            $this->query->calls[] = ['where', [$column, $operator]];
+        }
+
+        return $this;
+    }
+
     public function first(): ?Vehicle
     {
         return $this->result;
@@ -117,6 +128,8 @@ class FleetOpsVehicleModelFindableFake extends Vehicle
 
         if (is_callable($column)) {
             $column($query);
+        } else {
+            $query->calls[] = ['where', [$column, $operator]];
         }
 
         self::$lastQuery = $query;
@@ -258,9 +271,10 @@ test('vehicle import parses single vehicle name and find by name builds identifi
     FleetOpsVehicleModelFindableFake::$result = $found;
 
     expect(FleetOpsVehicleModelFindableFake::findByName('ABC-123'))->toBe($found)
+        ->and(FleetOpsVehicleModelFindableFake::$lastQuery->calls[0])->toBe(['where', ['company_uuid', 'company-vehicle']])
         ->and(FleetOpsVehicleModelFindableFake::$lastQuery->calls)->toContain(['where', ['public_id', 'ABC-123']])
         ->and(FleetOpsVehicleModelFindableFake::$lastQuery->calls)->toContain(['orWhere', ['plate_number', 'ABC-123']])
         ->and(FleetOpsVehicleModelFindableFake::$lastQuery->calls)->toContain(['orWhere', ['fuel_card_number', 'ABC-123']])
-        ->and(FleetOpsVehicleModelFindableFake::$lastQuery->calls[7][0])->toBe('orWhereRaw')
-        ->and(FleetOpsVehicleModelFindableFake::$lastQuery->calls[8][0])->toBe('orWhereRaw');
+        ->and(FleetOpsVehicleModelFindableFake::$lastQuery->calls[8][0])->toBe('orWhereRaw')
+        ->and(FleetOpsVehicleModelFindableFake::$lastQuery->calls[9][0])->toBe('orWhereRaw');
 });

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

@@ -218,9 +218,10 @@ test('waypoint insert filters values and creates payload tracking number', funct
     ])->and($inserted)->not->toHaveKey('not_allowed')
         ->and(FleetOpsWaypointInsertFake::$createdTracking)->toHaveCount(1)
         ->and(FleetOpsWaypointInsertFake::$createdTracking[0])->toMatchArray([
-            'owner_uuid' => 'waypoint-uuid',
-            'owner_type' => Utils::getModelClassName('waypoint'),
-            'region'     => 'AE',
+            'owner_uuid'      => 'waypoint-uuid',
+            'owner_type'      => Utils::getModelClassName('waypoint'),
+            'owner_public_id' => FleetOpsWaypointInsertFake::$insertedValues[0]['public_id'],
+            'region'          => 'AE',
         ])
         ->and(FleetOpsWaypointInsertFake::$createdTracking[0]['location'])->toBe('POINT(55.2708 25.2048)')
         ->and(FleetOpsWaypointInsertFake::$trackingNumberWrites)->toBe([

package/server/tests/Unit/Notifications/OrderChangeNotificationsTest.php

@@ -0,0 +1,59 @@
+<?php
+
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Models\TrackingNumber;
+use Fleetbase\FleetOps\Notifications\OrderChanged;
+use Fleetbase\FleetOps\Notifications\OrderUnassigned;
+use NotificationChannels\Apn\ApnChannel;
+use NotificationChannels\Fcm\FcmChannel;
+
+/**
+ * Covers the driver pushes for order changes and unassignment: their titles,
+ * bodies and the data the apps read.
+ */
+function fleetopsOrderChangeNotificationOrder(): Order
+{
+    $trackingNumber = new TrackingNumber();
+    $trackingNumber->setRawAttributes(['uuid' => 'tn-1', 'tracking_number' => 'FLB-CHANGE-1'], true);
+
+    $order = new Order();
+    $order->setRawAttributes([
+        'uuid'                 => 'order-uuid',
+        'public_id'            => 'order_change',
+        'company_uuid'         => 'company-1',
+        'driver_assigned_uuid' => 'driver-uuid',
+    ], true);
+    $order->setRelation('trackingNumber', $trackingNumber);
+    $order->setRelation('driverAssigned', null);
+
+    return $order;
+}
+
+test('order changed pushes the changes to the driver with fcm safe data', function () {
+    $notification = new OrderChanged(fleetopsOrderChangeNotificationOrder(), ['dropoff', 'items'], 'Drop-off changed to 8 Marina View · Items changed');
+
+    expect($notification->title)->toBe('Order FLB-CHANGE-1 changed')
+        ->and($notification->message)->toBe('Drop-off changed to 8 Marina View · Items changed')
+        ->and($notification->data)->toBe(['type' => 'order_changed', 'id' => 'order_change', 'changes' => ['dropoff', 'items']])
+        ->and($notification->fcmData())->toBe(['type' => 'order_changed', 'id' => 'order_change', 'changes' => 'dropoff,items'])
+        ->and($notification->via(null))->toBe(['broadcast', FcmChannel::class, ApnChannel::class])
+        ->and($notification->toArray())->toMatchArray(['event' => 'order.changed_notification', 'data' => $notification->data])
+        ->and(array_map(fn ($channel) => $channel->name, $notification->broadcastOn()))->toContain('driver.driver-uuid')
+        ->and((new OrderChanged(fleetopsOrderChangeNotificationOrder()))->message)->toBe('This order was changed, tap for details.');
+
+    // The push builders reach for the FCM and APN clients, which the harness does not configure
+    expect(fn () => $notification->toFcm(null))->toThrow(Exception::class)
+        ->and(fn () => $notification->toApn(null))->toThrow(Error::class);
+});
+
+test('order unassigned tells the driver the order is no longer theirs', function () {
+    $notification = new OrderUnassigned(fleetopsOrderChangeNotificationOrder());
+
+    expect($notification->title)->toBe('Order FLB-CHANGE-1 unassigned')
+        ->and($notification->data)->toBe(['type' => 'order_unassigned', 'id' => 'order_change'])
+        ->and($notification->via(null))->toBe([FcmChannel::class, ApnChannel::class])
+        ->and($notification->toArray()['event'])->toBe('order.unassigned_notification');
+
+    expect(fn () => $notification->toFcm(null))->toThrow(Exception::class)
+        ->and(fn () => $notification->toApn(null))->toThrow(Error::class);
+});

package/server/tests/Unit/Notifications/TerminalOrderNotificationsTest.php

@@ -141,7 +141,7 @@ test('completed order notification formats mail and array payloads from order tr
             'No further action is necessary.'
         )
         ->and($mail->actionText)->toBe('Track Order')
-        ->and($mail->actionUrl)->toContain('order=ORDER-TRACK');
+        ->and($mail->actionUrl)->toBe('https://console.fleetbase.test/~/track/ORDER-TRACK');
 });
 
 test('failed order notification formats mail and array payloads from waypoint tracking', function () {
@@ -166,7 +166,7 @@ test('failed order notification formats mail and array payloads from waypoint tr
             'No further action is necessary.'
         )
         ->and($mail->actionText)->toBe('Track Order')
-        ->and($mail->actionUrl)->toContain('order=WP-FAILED');
+        ->and($mail->actionUrl)->toBe('https://console.fleetbase.test/~/track/WP-FAILED');
 });
 
 test('dispatched order notification formats mail from waypoint tracking fallback', function () {
@@ -181,5 +181,5 @@ test('dispatched order notification formats mail from waypoint tracking fallback
         ->and($mail->subject)->toBe('Order WP-DISPATCHED has been dispatched!')
         ->and($mail->introLines)->toBe(['An order has just been dispatched to you and is ready to be started.'])
         ->and($mail->actionText)->toBe('Track Order')
-        ->and($mail->actionUrl)->toContain('order=WP-DISPATCHED');
+        ->and($mail->actionUrl)->toBe('https://console.fleetbase.test/~/track/WP-DISPATCHED');
 });