@fleetbase/fleetops-engine 0.6.58 → 0.6.60

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

@@ -0,0 +1,272 @@
+<?php
+
+if (!function_exists('Fleetbase\FleetOps\Models\activity')) {
+    eval('namespace Fleetbase\FleetOps\Models; function activity($logName = null) { return \FleetOpsWorkOrderActivityFake::start($logName); }');
+}
+
+if (!function_exists('Fleetbase\FleetOps\Models\auth')) {
+    eval('namespace Fleetbase\FleetOps\Models; function auth() { return new class { public function id() { return "work-order-user"; } }; }');
+}
+
+use Fleetbase\FleetOps\Models\Maintenance;
+use Fleetbase\FleetOps\Models\Vendor;
+use Fleetbase\FleetOps\Models\WorkOrder;
+use Fleetbase\Models\File;
+use Fleetbase\Models\User;
+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\Support\Carbon;
+use Spatie\Activitylog\LogOptions;
+
+class FleetOpsWorkOrderActivityFake
+{
+    public static array $entries = [];
+
+    public static function start(?string $logName = null): self
+    {
+        static::$entries[] = ['log_name' => $logName];
+
+        return new self(count(static::$entries) - 1);
+    }
+
+    public function __construct(private int $index)
+    {
+    }
+
+    public function performedOn($subject): self
+    {
+        static::$entries[$this->index]['subject'] = $subject;
+
+        return $this;
+    }
+
+    public function withProperties(array $properties): self
+    {
+        static::$entries[$this->index]['properties'] = $properties;
+
+        return $this;
+    }
+
+    public function log(string $message): bool
+    {
+        static::$entries[$this->index]['message'] = $message;
+
+        return true;
+    }
+}
+
+class FleetOpsWorkOrderDatabaseProbe
+{
+    public function __construct(private SQLiteConnection $connection)
+    {
+    }
+
+    public function connection(): SQLiteConnection
+    {
+        return $this->connection;
+    }
+}
+
+class FleetOpsWorkOrderUpdatingFake extends WorkOrder
+{
+    public array $updates = [];
+
+    public function __construct(array $attributes = [])
+    {
+        parent::__construct();
+
+        if ($attributes) {
+            $this->setRawAttributes($attributes, true);
+        }
+    }
+
+    public function getAttribute($key)
+    {
+        if (in_array($key, ['checklist', 'meta'], true)) {
+            return $this->attributes[$key] ?? null;
+        }
+
+        if (in_array($key, ['opened_at', 'due_at', 'closed_at'], true)) {
+            return isset($this->attributes[$key]) ? Carbon::parse($this->attributes[$key]) : null;
+        }
+
+        return parent::getAttribute($key);
+    }
+
+    public function update(array $attributes = [], array $options = []): bool
+    {
+        $this->updates[] = $attributes;
+        $this->setRawAttributes(array_merge($this->getAttributes(), $attributes), true);
+
+        return true;
+    }
+}
+
+class FleetOpsWorkOrderAssigneeFake extends Vendor
+{
+    public function getAttribute($key)
+    {
+        return $this->attributes[$key] ?? null;
+    }
+}
+
+function fleetopsWorkOrderUseConnection(): void
+{
+    $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
+    $resolver   = new ConnectionResolver([
+        'default' => $connection,
+        'mysql'   => $connection,
+    ]);
+
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+    app()->instance('db', new FleetOpsWorkOrderDatabaseProbe($connection));
+}
+
+beforeEach(function () {
+    fleetopsWorkOrderUseConnection();
+    FleetOpsWorkOrderActivityFake::$entries = [];
+    Carbon::setTestNow(Carbon::parse('2026-07-27 12:00:00'));
+});
+
+afterEach(function () {
+    Carbon::setTestNow();
+});
+
+test('work order relationship contracts and activity options are stable', function () {
+    $workOrder = new WorkOrder();
+
+    expect($workOrder->getActivitylogOptions())->toBeInstanceOf(LogOptions::class)
+        ->and($workOrder->createdBy())->toBeInstanceOf(BelongsTo::class)
+        ->and($workOrder->createdBy()->getRelated())->toBeInstanceOf(User::class)
+        ->and($workOrder->updatedBy())->toBeInstanceOf(BelongsTo::class)
+        ->and($workOrder->updatedBy()->getRelated())->toBeInstanceOf(User::class)
+        ->and($workOrder->target())->toBeInstanceOf(MorphTo::class)
+        ->and($workOrder->assignee())->toBeInstanceOf(MorphTo::class)
+        ->and($workOrder->maintenances())->toBeInstanceOf(HasMany::class)
+        ->and($workOrder->maintenances()->getRelated())->toBeInstanceOf(Maintenance::class)
+        ->and($workOrder->maintenances()->getForeignKeyName())->toBe('work_order_uuid')
+        ->and($workOrder->documents())->toBeInstanceOf(HasMany::class)
+        ->and($workOrder->documents()->getRelated())->toBeInstanceOf(File::class)
+        ->and($workOrder->documents()->getForeignKeyName())->toBe('subject_uuid');
+});
+
+test('work order lifecycle helpers update state and record activity', function () {
+    $assignee = new FleetOpsWorkOrderAssigneeFake();
+    $assignee->forceFill(['uuid' => 'vendor-uuid', 'name' => 'Vendor Crew']);
+
+    $workOrder = new FleetOpsWorkOrderUpdatingFake([
+        'uuid'      => 'work-order-uuid',
+        'status'    => 'open',
+        'opened_at' => null,
+        'meta'      => ['existing' => true],
+    ]);
+
+    expect($workOrder->assignTo($assignee))->toBeTrue()
+        ->and($workOrder->updates[0])->toBe([
+            'assignee_type' => FleetOpsWorkOrderAssigneeFake::class,
+            'assignee_uuid' => 'vendor-uuid',
+        ])
+        ->and($workOrder->start())->toBeTrue()
+        ->and($workOrder->updates[1]['status'])->toBe('in_progress')
+        ->and($workOrder->updates[1]['opened_at']->toDateTimeString())->toBe('2026-07-27 12:00:00')
+        ->and($workOrder->complete(['notes' => 'Done']))->toBeTrue()
+        ->and($workOrder->updates[2]['status'])->toBe('closed')
+        ->and($workOrder->updates[2]['closed_at']->toDateTimeString())->toBe('2026-07-27 12:00:00')
+        ->and($workOrder->updates[2]['meta'])->toBe([
+            'existing'         => true,
+            'completion_data'  => ['notes' => 'Done'],
+        ])
+        ->and(FleetOpsWorkOrderActivityFake::$entries[0]['log_name'])->toBe('work_order_assigned')
+        ->and(FleetOpsWorkOrderActivityFake::$entries[0]['properties'])->toBe([
+            'assigned_to_type' => FleetOpsWorkOrderAssigneeFake::class,
+            'assigned_to_uuid' => 'vendor-uuid',
+            'assigned_to_name' => 'Vendor Crew',
+        ])
+        ->and(FleetOpsWorkOrderActivityFake::$entries[0]['message'])->toBe('Work order assigned')
+        ->and(FleetOpsWorkOrderActivityFake::$entries[1]['log_name'])->toBe('work_order_started')
+        ->and(FleetOpsWorkOrderActivityFake::$entries[1]['message'])->toBe('Work order started')
+        ->and(FleetOpsWorkOrderActivityFake::$entries[2]['log_name'])->toBe('work_order_completed')
+        ->and(FleetOpsWorkOrderActivityFake::$entries[2]['properties'])->toBe(['notes' => 'Done'])
+        ->and(FleetOpsWorkOrderActivityFake::$entries[2]['message'])->toBe('Work order completed');
+});
+
+test('work order lifecycle guards reject invalid transitions and cancel open work', function () {
+    $closed = new FleetOpsWorkOrderUpdatingFake(['status' => 'closed']);
+
+    expect($closed->start())->toBeFalse()
+        ->and($closed->complete())->toBeFalse()
+        ->and($closed->cancel('duplicate'))->toBeFalse()
+        ->and($closed->updates)->toBe([]);
+
+    $workOrder = new FleetOpsWorkOrderUpdatingFake([
+        'status' => 'in_progress',
+        'meta'   => ['existing' => true],
+    ]);
+
+    expect($workOrder->cancel('No longer needed'))->toBeTrue()
+        ->and($workOrder->updates[0]['status'])->toBe('canceled')
+        ->and($workOrder->updates[0]['closed_at']->toDateTimeString())->toBe('2026-07-27 12:00:00')
+        ->and($workOrder->updates[0]['meta'])->toBe([
+            'existing'             => true,
+            'cancellation_reason'  => 'No longer needed',
+        ])
+        ->and(FleetOpsWorkOrderActivityFake::$entries[0]['log_name'])->toBe('work_order_canceled')
+        ->and(FleetOpsWorkOrderActivityFake::$entries[0]['properties'])->toBe(['reason' => 'No longer needed'])
+        ->and(FleetOpsWorkOrderActivityFake::$entries[0]['message'])->toBe('Work order canceled');
+});
+
+test('work order checklist helpers use authenticated fallback and schedule helpers handle nulls', function () {
+    $workOrder = new FleetOpsWorkOrderUpdatingFake([
+        'status'    => 'open',
+        'checklist' => [
+            ['label' => 'Inspect liftgate', 'completed' => false],
+        ],
+    ]);
+
+    expect($workOrder->completeChecklistItem(0))->toBeTrue()
+        ->and($workOrder->updates[0]['checklist'][0]['completed'])->toBeTrue()
+        ->and($workOrder->updates[0]['checklist'][0]['completed_at']->toDateTimeString())->toBe('2026-07-27 12:00:00')
+        ->and($workOrder->updates[0]['checklist'][0]['completed_by'])->toBe('work-order-user')
+        ->and($workOrder->getActualDuration())->toBeNull()
+        ->and($workOrder->isOnSchedule())->toBeNull();
+});
+
+test('work order timing and priority helpers cover overdue and open schedule branches', function () {
+    $overdue = new FleetOpsWorkOrderUpdatingFake([
+        'status'   => 'open',
+        'due_at'   => '2026-07-26 12:00:00',
+        'priority' => 'critical',
+    ]);
+
+    $future = new FleetOpsWorkOrderUpdatingFake([
+        'status'   => 'in_progress',
+        'due_at'   => '2026-07-28 12:00:00',
+        'priority' => 'medium',
+    ]);
+
+    $closedLate = new FleetOpsWorkOrderUpdatingFake([
+        'status'    => 'closed',
+        'opened_at' => '2026-07-25 12:00:00',
+        'closed_at' => '2026-07-27 12:00:00',
+        'due_at'    => '2026-07-26 12:00:00',
+        'priority'  => 'low',
+    ]);
+
+    expect($overdue->is_overdue)->toBeTrue()
+        ->and($overdue->days_until_due)->toBe(-1)
+        ->and($overdue->isOnSchedule())->toBeFalse()
+        ->and($overdue->getPriorityLevel())->toBe(5)
+        ->and($future->is_overdue)->toBeFalse()
+        ->and($future->days_until_due)->toBe(1)
+        ->and($future->isOnSchedule())->toBeTrue()
+        ->and($future->getPriorityLevel())->toBe(3)
+        ->and($closedLate->getActualDuration())->toBe(48.0)
+        ->and($closedLate->isOnSchedule())->toBeFalse()
+        ->and($closedLate->getPriorityLevel())->toBe(2)
+        ->and((new FleetOpsWorkOrderUpdatingFake(['priority' => 'unknown']))->getPriorityLevel())->toBe(1);
+});

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

@@ -0,0 +1,83 @@
+<?php
+
+if (!function_exists('Fleetbase\Traits\config')) {
+    eval('namespace Fleetbase\Traits; function config($key = null, $default = null) { return $default; }');
+}
+
+use Fleetbase\FleetOps\Models\ServiceArea;
+use Fleetbase\FleetOps\Models\Zone;
+use Fleetbase\LaravelMysqlSpatial\Types\LineString;
+use Fleetbase\LaravelMysqlSpatial\Types\Point;
+use Fleetbase\LaravelMysqlSpatial\Types\Polygon;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+function fleetopsZoneUnitUseInMemoryRelationConnection(): void
+{
+    $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
+    $resolver   = new ConnectionResolver([
+        'default' => $connection,
+        'mysql'   => $connection,
+    ]);
+
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+}
+
+function fleetopsZoneUnitBorder(): Polygon
+{
+    return new Polygon([
+        new LineString([
+            new Point(1.30, 103.80),
+            new Point(1.30, 103.90),
+            new Point(1.40, 103.90),
+            new Point(1.40, 103.80),
+            new Point(1.30, 103.80),
+        ]),
+    ]);
+}
+
+test('zone exposes service area relation metadata and static type', function () {
+    fleetopsZoneUnitUseInMemoryRelationConnection();
+
+    $zone        = new Zone();
+    $serviceArea = $zone->serviceArea();
+
+    expect($serviceArea->getRelated())->toBeInstanceOf(ServiceArea::class)
+        ->and($serviceArea->getForeignKeyName())->toBe('service_area_uuid')
+        ->and($serviceArea->getOwnerKeyName())->toBe('uuid')
+        ->and($zone->type)->toBe('zone');
+});
+
+test('zone returns empty geos shapes when border cannot create a polygon', function () {
+    $zone = new Zone();
+    $zone->setRawAttributes(['border' => null], true);
+
+    expect($zone->toGeosLineStrings())->toBe([])
+        ->and($zone->toGeosPolygon())->toBeNull();
+});
+
+test('zone converts populated borders into geos line strings and polygons', function () {
+    $zone = new Zone();
+    $zone->setRawAttributes(['border' => fleetopsZoneUnitBorder()], true);
+
+    $lineStrings = $zone->toGeosLineStrings();
+    $polygon     = $zone->toGeosPolygon();
+
+    expect($lineStrings)->toHaveCount(1)
+        ->and((string) $lineStrings[0]->pointN(1))->toBe('POINT (1.3 103.8)')
+        ->and($polygon)->toBeInstanceOf(Brick\Geo\Polygon::class);
+});
+
+test('zone creates closed spatial polygons around center points', function () {
+    $point   = new Point(1.35, 103.85);
+    $polygon = Zone::createPolygonFromPoint($point, 250);
+
+    $lineString = $polygon->getLineStrings()[0];
+    $points     = $lineString->getPoints();
+
+    expect($polygon)->toBeInstanceOf(Polygon::class)
+        ->and($points)->not->toBeEmpty()
+        ->and((string) $points[0])->toBe((string) $points[array_key_last($points)]);
+});

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

@@ -0,0 +1,136 @@
+<?php
+
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Models\Waypoint;
+use Fleetbase\FleetOps\Notifications\LateDeparture;
+use Fleetbase\FleetOps\Notifications\ProlongedStoppage;
+use Fleetbase\FleetOps\Notifications\RouteDeviation;
+use Fleetbase\FleetOps\Notifications\WaypointCompleted;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Notifications\Messages\MailMessage;
+
+/**
+ * Covers the fleet monitoring notifications: the late-departure,
+ * prolonged-stoppage, and route-deviation mail bodies with tracking/public-id
+ * fallback, and the waypoint-completed broadcast channel construction plus
+ * its push channel seams.
+ */
+function fleetopsMonitoringNotifBoot(): 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 = [
+        'orders'           => ['uuid', 'public_id', 'company_uuid', 'payload_uuid', 'status'],
+        'tracking_numbers' => ['uuid', 'public_id', 'company_uuid', 'tracking_number', 'owner_uuid'],
+        'companies'        => ['uuid', 'public_id', 'name'],
+    ];
+    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();
+        });
+    }
+
+    session(['company' => 'company-1', 'api_credential' => 'console']);
+
+    return $connection;
+}
+
+function fleetopsMonitoringNotifOrder(): Order
+{
+    $order = new Order();
+    $order->setRawAttributes([
+        'uuid'      => 'order-1',
+        'public_id' => 'order_test',
+        'tracking'  => 'TRK-42',
+    ], true);
+    $order->exists = true;
+
+    return $order;
+}
+
+test('monitoring notifications render mail bodies and database payloads', function () {
+    fleetopsMonitoringNotifBoot();
+    $order = fleetopsMonitoringNotifOrder();
+
+    foreach ([
+        [new LateDeparture($order, ['grace' => 15]), 'Late departure', 'order.late_departure'],
+        [new ProlongedStoppage($order, ['minutes' => 30]), 'Prolonged stoppage', 'order.prolonged_stoppage'],
+        [new RouteDeviation($order, ['meters' => 500]), 'Route deviation', 'order.route_deviation'],
+    ] as [$notification, $subjectFragment, $event]) {
+        expect($notification->via(null))->toBe(['mail', 'database']);
+
+        // Order.tracking resolves through the tracking-number relation, which
+        // is absent here, so the public id fallback renders in mail bodies.
+        $mail = $notification->toMail(null);
+        expect($mail)->toBeInstanceOf(MailMessage::class)
+            ->and($mail->subject)->toContain('order_test');
+
+        $payload = $notification->toArray(null);
+        expect($payload['event'])->toBe($event)
+            ->and($payload['order_uuid'])->toBe('order-1')
+            ->and($payload['message'])->toContain('order_test');
+    }
+});
+
+test('waypoint completed broadcasts on order channels and exposes push seams', function () {
+    $connection = fleetopsMonitoringNotifBoot();
+    $connection->table('orders')->insert(['uuid' => 'order-1', 'public_id' => 'order_test', 'payload_uuid' => 'payload-1', 'company_uuid' => 'company-1']);
+
+    $waypoint = new Waypoint();
+    $waypoint->setRawAttributes(['uuid' => 'wp-1', 'public_id' => 'waypoint_1', 'payload_uuid' => 'payload-1', 'tracking_number_uuid' => 'tn-1'], true);
+    $waypoint->exists = true;
+
+    $trackingNumber = new Fleetbase\FleetOps\Models\TrackingNumber();
+    $trackingNumber->setRawAttributes(['uuid' => 'tn-1', 'tracking_number' => 'WPTRK-1'], true);
+    $waypoint->setRelation('trackingNumber', $trackingNumber);
+
+    $activity = new Fleetbase\FleetOps\Flow\Activity(['code' => 'COMPLETED', 'details' => 'Waypoint completed']);
+
+    $notification = new WaypointCompleted($waypoint, $activity);
+
+    expect($notification->via(null))->toContain('broadcast', 'mail');
+
+    $channels = $notification->broadcastOn();
+    expect(count($channels))->toBe(5)
+        ->and($channels[3]->name)->toBe('order.order-1')
+        ->and($channels[4]->name)->toBe('order.order_test');
+
+    // Without a matching order only the api channel remains
+    $connection->table('orders')->delete();
+    expect($notification->broadcastOn())->toHaveCount(1);
+
+    expect($notification->toArray()['title'])->not->toBeNull();
+
+    // Push transports and console urls are unavailable in the harness; the
+    // delegation bodies still execute up to those seams.
+    expect(fn () => $notification->toMail(null))->toThrow(Error::class)
+        ->and(fn () => $notification->toFcm(null))->toThrow(Exception::class)
+        ->and(fn () => $notification->toApn(null))->toThrow(Error::class);
+});

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

@@ -0,0 +1,53 @@
+<?php
+
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Models\TrackingNumber;
+use Fleetbase\FleetOps\Notifications\OrderAssigned;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+/**
+ * Covers the OrderAssigned notification's fcm/apn push channel seams. The
+ * transport packages are unavailable in the harness, so the assertion is that
+ * the delegation bodies execute and fail inside the transport rather than
+ * before reaching it.
+ */
+function fleetopsOrderAssignedOrder(): Order
+{
+    $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
+    $resolver   = new ConnectionResolver(['default' => $connection, 'mysql' => $connection]);
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+
+    $trackingNumber = new TrackingNumber();
+    $trackingNumber->setRawAttributes(['uuid' => 'tn-assigned-1', 'tracking_number' => 'FLB-ASSIGNED-1'], true);
+
+    $order = new Order();
+    $order->setRawAttributes([
+        'uuid'      => 'order-assigned-1',
+        'public_id' => 'order_assignedone',
+        'status'    => 'assigned',
+    ], true);
+    $order->setRelation('trackingNumber', $trackingNumber);
+    $order->exists = true;
+
+    return $order;
+}
+
+test('order assigned builds title message and payload data', function () {
+    $notification = new OrderAssigned(fleetopsOrderAssignedOrder());
+
+    expect($notification->title)->toBe('New order FLB-ASSIGNED-1 assigned!')
+        ->and($notification->message)->toBe('You have a new order assigned, tap for details.')
+        ->and($notification->data)->toBe(['id' => 'order_assignedone', 'type' => 'order_assigned']);
+});
+
+test('order assigned push channel seams execute their delegation bodies', function () {
+    $notification = new OrderAssigned(fleetopsOrderAssignedOrder());
+
+    // The fcm/apn transport packages are unavailable in the harness; the
+    // delegation bodies still execute, which is the covered contract here.
+    expect(fn () => $notification->toFcm(null))->toThrow(Exception::class)
+        ->and(fn () => $notification->toApn(null))->toThrow(Error::class);
+});

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

@@ -0,0 +1,81 @@
+<?php
+
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Models\Waypoint;
+use Fleetbase\FleetOps\Notifications\OrderDispatched;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Notifications\Messages\BroadcastMessage;
+
+/**
+ * Covers the OrderDispatched notification's broadcast payload construction,
+ * mail representation with waypoint/order tracking-number fallback, and the
+ * fcm/apn push channel seams (their delegation bodies execute; the transport
+ * packages are unavailable in the harness).
+ */
+function fleetopsOrderDispatchedBoot(): void
+{
+    $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
+    $resolver   = new ConnectionResolver(['default' => $connection, 'mysql' => $connection]);
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+}
+
+function fleetopsOrderDispatchedOrder(): Order
+{
+    $order = new Order();
+    $order->setRawAttributes([
+        'uuid'      => 'order-1',
+        'public_id' => 'order_test',
+        'status'    => 'dispatched',
+    ], true);
+    $order->exists = true;
+
+    return $order;
+}
+
+test('order dispatched builds title message and payload data', function () {
+    fleetopsOrderDispatchedBoot();
+
+    $notification = new OrderDispatched(fleetopsOrderDispatchedOrder());
+
+    expect($notification->title)->toContain('has been dispatched')
+        ->and($notification->message)->toContain('ready to be started')
+        ->and($notification->data)->toBe(['id' => 'order_test', 'type' => 'order_dispatched']);
+});
+
+test('order dispatched broadcast message wraps the serialized order resource', function () {
+    fleetopsOrderDispatchedBoot();
+
+    $broadcast = (new OrderDispatched(fleetopsOrderDispatchedOrder()))->toBroadcast(null);
+
+    expect($broadcast)->toBeInstanceOf(BroadcastMessage::class)
+        ->and($broadcast->data['event'])->toBe('order.dispatched')
+        ->and($broadcast->data['id'])->toStartWith('event_')
+        ->and($broadcast->data)->toHaveKeys(['api_version', 'created_at', 'data']);
+});
+
+test('order dispatched mail seam executes with waypoint tracking fallback', function () {
+    fleetopsOrderDispatchedBoot();
+
+    $order    = fleetopsOrderDispatchedOrder();
+    $waypoint = new Waypoint();
+    $waypoint->setRawAttributes(['uuid' => 'wp-1', 'tracking' => 'WPTRK-9'], true);
+
+    // Utils::consoleUrl requires the full application environment; the mail
+    // body executes through subject/line and the tracking-number resolution
+    // for both the order and waypoint variants before reaching that seam.
+    expect(fn () => (new OrderDispatched($order))->toMail(null))->toThrow(Error::class)
+        ->and(fn () => (new OrderDispatched($order, $waypoint))->toMail(null))->toThrow(Error::class);
+});
+
+test('order dispatched push channel seams execute their delegation bodies', function () {
+    fleetopsOrderDispatchedBoot();
+    $notification = new OrderDispatched(fleetopsOrderDispatchedOrder());
+
+    // The fcm/apn transport packages are unavailable in the harness; the
+    // delegation bodies still execute, which is the covered contract here.
+    expect(fn () => $notification->toFcm(null))->toThrow(Exception::class)
+        ->and(fn () => $notification->toApn(null))->toThrow(Error::class);
+});