@fleetbase/fleetops-engine 0.6.58 → 0.6.59

package/server/tests/Unit/Listeners/HandleOrderDispatchFailedListenerTest.php

@@ -0,0 +1,101 @@
+<?php
+
+use Fleetbase\FleetOps\Events\OrderDispatchFailed;
+use Fleetbase\FleetOps\Listeners\HandleOrderDispatchFailed;
+use Fleetbase\FleetOps\Models\Order;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Support\Str;
+
+/**
+ * Covers the HandleOrderDispatchFailed listener's real helper bodies: the
+ * order creator lookup against SQLite and the failure notification hand-off
+ * through a notification dispatcher fake.
+ */
+class FleetOpsDispatchFailedEventStub extends OrderDispatchFailed
+{
+    public function __construct(private Order $order)
+    {
+        $this->reason = 'no driver available';
+    }
+
+    public function getModelRecord(): Order
+    {
+        return $this->order;
+    }
+}
+
+function fleetopsDispatchFailedBoot(): SQLiteConnection
+{
+    if (!Str::hasMacro('humanize')) {
+        Str::macro('humanize', fn ($value, $uppercase = true) => str_replace('_', ' ', Str::snake((string) $value)));
+    }
+
+    $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('users', function ($blueprint) {
+        $blueprint->increments('id');
+        foreach (['uuid', 'public_id', 'company_uuid', 'name', 'email', 'status', 'type'] as $column) {
+            $blueprint->string($column)->nullable();
+        }
+        $blueprint->timestamps();
+        $blueprint->timestamp('deleted_at')->nullable();
+    });
+
+    session(['company' => 'company-1']);
+
+    return $connection;
+}
+
+test('dispatch failed listener notifies the order creator when found', function () {
+    $connection = fleetopsDispatchFailedBoot();
+    $connection->table('users')->insert(['uuid' => 'user-1', 'company_uuid' => 'company-1', 'name' => 'Creator']);
+
+    $dispatcher = new class implements Illuminate\Contracts\Notifications\Dispatcher {
+        public array $sent = [];
+
+        public function send($notifiables, $notification)
+        {
+            $this->sent[] = $notification;
+        }
+
+        public function sendNow($notifiables, $notification, ?array $channels = null)
+        {
+            $this->sent[] = $notification;
+        }
+    };
+    app()->instance(Illuminate\Contracts\Notifications\Dispatcher::class, $dispatcher);
+
+    $order = new Order();
+    $order->setRawAttributes(['uuid' => 'order-1', 'public_id' => 'order_test', 'created_by_uuid' => 'user-1', 'tracking' => 'TRK-1'], true);
+    $order->exists = true;
+
+    (new HandleOrderDispatchFailed())->handle(new FleetOpsDispatchFailedEventStub($order));
+    expect($dispatcher->sent)->toHaveCount(1);
+
+    // Unknown creators skip notification entirely
+    $order->created_by_uuid = 'user-missing';
+    (new HandleOrderDispatchFailed())->handle(new FleetOpsDispatchFailedEventStub($order));
+    expect($dispatcher->sent)->toHaveCount(1);
+});

package/server/tests/Unit/Listeners/HandleOrderDispatchedConcreteTest.php

@@ -0,0 +1,203 @@
+<?php
+
+use Fleetbase\FleetOps\Events\OrderDispatched;
+use Fleetbase\FleetOps\Flow\Activity;
+use Fleetbase\FleetOps\Listeners\HandleOrderDispatched;
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Models\OrderConfig;
+use Illuminate\Support\Str;
+
+if (!Str::hasMacro('humanize')) {
+    Str::macro('humanize', fn ($value) => str_replace('_', ' ', Str::snake((string) $value)));
+}
+
+class FleetOpsConcreteOrderDispatchedEvent extends OrderDispatched
+{
+    public function __construct(private Order $order)
+    {
+    }
+
+    public function getModelRecord(): Order
+    {
+        return $this->order;
+    }
+}
+
+class FleetOpsConcreteOrderForDispatch extends Order
+{
+    public bool $hasDriverAssigned       = true;
+    public bool $adhoc                   = false;
+    public ?string $company_uuid         = 'company-uuid';
+    public ?string $tracking_number_uuid = 'tracking-number-uuid';
+    public ?string $driver_assigned_uuid = 'driver-uuid';
+    public mixed $dispatched             = false;
+    public mixed $dispatched_at          = null;
+    public mixed $pickupLocation         = null;
+    public ?OrderConfig $dispatchConfig  = null;
+    public int $adhocDistance            = 1500;
+    public array $calls                  = [];
+
+    public function config(): ?OrderConfig
+    {
+        return $this->dispatchConfig;
+    }
+
+    public function save(array $options = []): bool
+    {
+        $this->calls[] = ['save', $options];
+
+        return true;
+    }
+
+    public function flushAttributesCache(): bool
+    {
+        $this->calls[] = ['flushAttributesCache'];
+
+        return true;
+    }
+
+    public function load($relations)
+    {
+        $this->calls[] = ['load', $relations];
+
+        return $this;
+    }
+
+    public function getPickupLocation()
+    {
+        return $this->pickupLocation;
+    }
+
+    public function getAdhocDistance()
+    {
+        return $this->adhocDistance;
+    }
+}
+
+class FleetOpsConcreteOrderConfigForDispatch extends OrderConfig
+{
+    public ?Activity $dispatchActivity = null;
+
+    public function getDispatchActivity(): ?Activity
+    {
+        return $this->dispatchActivity;
+    }
+}
+
+class FleetOpsConcreteDriverForDispatch extends Driver
+{
+    public float $distance      = 0;
+    public array $notifications = [];
+
+    public function notify($instance)
+    {
+        $this->notifications[] = $instance;
+    }
+}
+
+class FleetOpsConcreteHandleOrderDispatchedProbe extends HandleOrderDispatched
+{
+    public ?Driver $assignedDriver         = null;
+    public bool $throwAssignedNotification = false;
+    public bool $throwAdhocNotification    = false;
+    public array $assignedNotifications    = [];
+    public array $adhocNotifications       = [];
+
+    public function getDispatchActivityForTest(Order $order): mixed
+    {
+        return $this->getDispatchActivity($order);
+    }
+
+    protected function doesntHaveDispatchActivity($order): bool
+    {
+        return false;
+    }
+
+    protected function findAssignedDriver($order): ?Driver
+    {
+        return $this->assignedDriver;
+    }
+
+    protected function nearbyAvailableDrivers($pickup, int|float $distance)
+    {
+        return collect([
+            new FleetOpsConcreteDriverForDispatch(),
+        ]);
+    }
+
+    protected function notifyAssignedDriver(Driver $driver, $order): void
+    {
+        if ($this->throwAssignedNotification) {
+            throw new RuntimeException('assigned notification failed');
+        }
+
+        $this->assignedNotifications[] = $driver;
+        parent::notifyAssignedDriver($driver, $order);
+    }
+
+    protected function notifyAdhocDriver(Driver $driver, $order): void
+    {
+        if ($this->throwAdhocNotification) {
+            throw new RuntimeException('adhoc notification failed');
+        }
+
+        $this->adhocNotifications[] = $driver;
+        parent::notifyAdhocDriver($driver, $order);
+    }
+}
+
+function fleetopsConcreteOrderForDispatch(array $attributes = []): FleetOpsConcreteOrderForDispatch
+{
+    $order = new FleetOpsConcreteOrderForDispatch();
+    $order->setRawAttributes(array_merge([
+        'uuid'      => 'order-uuid',
+        'public_id' => 'order_public',
+        'tracking'  => 'TRK-123',
+    ], $attributes), true);
+    $order->exists = true;
+
+    return $order;
+}
+
+test('order dispatched concrete dispatch activity helper returns nullable activity', function () {
+    $listener = new FleetOpsConcreteHandleOrderDispatchedProbe();
+    $order    = fleetopsConcreteOrderForDispatch();
+    $activity = new Activity(['code' => 'DISPATCHED']);
+
+    expect($listener->getDispatchActivityForTest($order))->toBeNull();
+
+    $config                   = new FleetOpsConcreteOrderConfigForDispatch();
+    $config->dispatchActivity = $activity;
+    $order->dispatchConfig    = $config;
+
+    expect($listener->getDispatchActivityForTest($order))->toBe($activity);
+});
+
+test('order dispatched listener swallows assigned driver notification failures', function () {
+    $listener = new FleetOpsConcreteHandleOrderDispatchedProbe();
+    $order    = fleetopsConcreteOrderForDispatch();
+
+    $listener->assignedDriver            = new FleetOpsConcreteDriverForDispatch();
+    $listener->throwAssignedNotification = true;
+
+    $listener->handle(new FleetOpsConcreteOrderDispatchedEvent($order));
+
+    expect($order->dispatched)->toBeTrue()
+        ->and($listener->assignedNotifications)->toBe([]);
+});
+
+test('order dispatched listener swallows adhoc driver notification failures', function () {
+    $listener                 = new FleetOpsConcreteHandleOrderDispatchedProbe();
+    $order                    = fleetopsConcreteOrderForDispatch();
+    $order->adhoc             = true;
+    $order->hasDriverAssigned = false;
+    $order->pickupLocation    = new Fleetbase\LaravelMysqlSpatial\Types\Point(1.30, 103.80);
+
+    $listener->throwAdhocNotification = true;
+
+    $listener->handle(new FleetOpsConcreteOrderDispatchedEvent($order));
+
+    expect($order->dispatched)->toBeTrue()
+        ->and($listener->adhocNotifications)->toBe([]);
+});

package/server/tests/Unit/Listeners/HandleOrderDispatchedHelpersTest.php

@@ -0,0 +1,186 @@
+<?php
+
+use Fleetbase\FleetOps\Events\OrderDispatchFailed;
+use Fleetbase\FleetOps\Listeners\HandleOrderDispatched;
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\LaravelMysqlSpatial\Types\Point;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Support\Str;
+
+/**
+ * Covers the real HandleOrderDispatched protected helper implementations
+ * (the concrete-listener test overrides them): the dispatch-failed event
+ * construction, dispatch-activity existence check, the nearby-available
+ * driver spatial query with the company/user/driver whereHas chain, and
+ * the driver notification helpers.
+ *
+ * The `users.driver` relation is registered through the core Expandable
+ * `expand()` mechanism — the core model's `__call` forwards unknown methods
+ * straight to the query builder, so Eloquent's `resolveRelationUsing`
+ * resolvers are never consulted.
+ */
+if (!function_exists('Fleetbase\FleetOps\Listeners\event')) {
+    eval('namespace Fleetbase\FleetOps\Listeners; function event($event = null) { \FleetOpsDispatchHelperRecorder::$events[] = $event; return [$event]; }');
+}
+
+class FleetOpsDispatchHelperRecorder
+{
+    public static array $events = [];
+}
+
+class FleetOpsDispatchHelperProbe extends HandleOrderDispatched
+{
+    public function callHelper(string $method, ...$arguments): mixed
+    {
+        return $this->{$method}(...$arguments);
+    }
+}
+
+class FleetOpsDispatchNotificationFake implements Illuminate\Contracts\Notifications\Dispatcher
+{
+    public array $sent = [];
+
+    public function send($notifiables, $notification)
+    {
+        $this->sent[] = $notification;
+    }
+
+    public function sendNow($notifiables, $notification, ?array $channels = null)
+    {
+        $this->sent[] = $notification;
+    }
+}
+
+function fleetopsDispatchHelperBoot(): SQLiteConnection
+{
+    if (!Str::hasMacro('humanize')) {
+        Str::macro('humanize', fn ($value, $uppercase = true) => str_replace('_', ' ', Str::snake((string) $value)));
+    }
+
+    $pdo = new PDO('sqlite::memory:');
+    $pdo->sqliteCreateFunction('ST_X', fn ($value) => 0.5);
+    $pdo->sqliteCreateFunction('ST_Y', fn ($value) => 0.5);
+    $pdo->sqliteCreateFunction('ST_GeomFromText', fn ($wkt, $srid = 0, $axisOrder = null) => $wkt);
+    $pdo->sqliteCreateFunction('ST_PointFromText', fn ($wkt, $srid = 0, $axisOrder = null) => $wkt);
+    $pdo->sqliteCreateFunction('st_distance_sphere', fn ($a, $b) => 100.0);
+    $connection = new SQLiteConnection($pdo);
+    $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', 'tracking_number_uuid', 'driver_assigned_uuid', 'status', 'adhoc', 'dispatched', 'dispatched_at', 'payload_uuid', 'meta', 'type'],
+        'tracking_statuses' => ['uuid', 'company_uuid', 'code', 'tracking_number_uuid', 'status', 'details'],
+        'tracking_numbers'  => ['uuid', 'public_id', 'company_uuid', 'tracking_number', 'owner_uuid', 'owner_type', 'status_uuid', 'type'],
+        'drivers'           => ['uuid', 'public_id', 'company_uuid', 'user_uuid', 'vehicle_uuid', 'status', 'online', 'location', 'meta'],
+        'companies'         => ['uuid', 'public_id', 'name'],
+        'company_users'     => ['uuid', 'company_uuid', 'user_uuid'],
+        'users'             => ['uuid', 'public_id', 'company_uuid', 'name', 'phone', 'email'],
+        'vehicles'          => ['uuid', 'public_id', 'company_uuid'],
+    ];
+    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']);
+    Fleetbase\Models\User::expand('driver', function () {
+        return $this->hasOne(Driver::class, 'user_uuid', 'uuid')->withoutGlobalScopes();
+    });
+    FleetOpsDispatchHelperRecorder::$events = [];
+
+    $connection->table('tracking_numbers')->insert(['uuid' => 'tn-1', 'company_uuid' => 'company-1', 'tracking_number' => 'TRK-1']);
+    $connection->table('orders')->insert(['uuid' => 'order-1', 'public_id' => 'order_1', 'company_uuid' => 'company-1', 'tracking_number_uuid' => 'tn-1']);
+    $connection->table('companies')->insert(['uuid' => 'company-1', 'name' => 'Acme']);
+    $connection->table('users')->insert(['uuid' => 'user-1', 'company_uuid' => 'company-1', 'name' => 'Driver One']);
+    $connection->table('company_users')->insert(['uuid' => 'cu-1', 'company_uuid' => 'company-1', 'user_uuid' => 'user-1']);
+    $connection->table('drivers')->insert(['uuid' => 'driver-1', 'company_uuid' => 'company-1', 'user_uuid' => 'user-1', 'status' => 'available', 'online' => '1', 'location' => 'POINT(1 1)']);
+
+    return $connection;
+}
+
+test('dispatch failed helper emits the lifecycle failure event', function () {
+    fleetopsDispatchHelperBoot();
+    $order = Order::where('uuid', 'order-1')->withoutGlobalScopes()->first();
+
+    $probe = new FleetOpsDispatchHelperProbe();
+    $probe->callHelper('dispatchFailed', $order, 'Order was dispatched, but driver was unable to be notified.');
+
+    expect(FleetOpsDispatchHelperRecorder::$events)->toHaveCount(1)
+        ->and(FleetOpsDispatchHelperRecorder::$events[0])->toBeInstanceOf(OrderDispatchFailed::class)
+        ->and(FleetOpsDispatchHelperRecorder::$events[0]->getReason())->toContain('unable to be notified');
+});
+
+test('dispatch activity existence check reflects tracking statuses', function () {
+    $connection = fleetopsDispatchHelperBoot();
+    $order      = Order::where('uuid', 'order-1')->withoutGlobalScopes()->first();
+
+    $probe = new FleetOpsDispatchHelperProbe();
+    expect($probe->callHelper('doesntHaveDispatchActivity', $order))->toBeTrue();
+
+    $connection->table('tracking_statuses')->insert(['uuid' => 'ts-1', 'code' => 'DISPATCHED', 'tracking_number_uuid' => 'tn-1']);
+    expect($probe->callHelper('doesntHaveDispatchActivity', $order))->toBeFalse();
+});
+
+test('nearby available drivers runs the spatial company scoped query', function () {
+    $connection = fleetopsDispatchHelperBoot();
+
+    $probe   = new FleetOpsDispatchHelperProbe();
+    $drivers = $probe->callHelper('nearbyAvailableDrivers', new Point(1.3, 103.8), 5000);
+
+    expect($drivers)->toHaveCount(1)
+        ->and($drivers->first()->uuid)->toBe('driver-1');
+
+    // Offline drivers are excluded
+    $connection->table('drivers')->where('uuid', 'driver-1')->update(['online' => '0']);
+    expect($probe->callHelper('nearbyAvailableDrivers', new Point(1.3, 103.8), 5000))->toHaveCount(0);
+});
+
+test('assigned driver lookup and notification helpers resolve and send', function () {
+    fleetopsDispatchHelperBoot();
+    $order                       = Order::where('uuid', 'order-1')->withoutGlobalScopes()->first();
+    $order->driver_assigned_uuid = 'driver-1';
+
+    $probe  = new FleetOpsDispatchHelperProbe();
+    $driver = $probe->callHelper('findAssignedDriver', $order);
+    expect($driver)->toBeInstanceOf(Driver::class)
+        ->and($driver->uuid)->toBe('driver-1');
+
+    $order->driver_assigned_uuid = 'driver-missing';
+    expect($probe->callHelper('findAssignedDriver', $order))->toBeNull();
+
+    $dispatcher = new FleetOpsDispatchNotificationFake();
+    app()->instance(Illuminate\Contracts\Notifications\Dispatcher::class, $dispatcher);
+
+    $probe->callHelper('notifyAssignedDriver', $driver, $order);
+    $driver->distance = 250;
+    $probe->callHelper('notifyAdhocDriver', $driver, $order);
+
+    expect($dispatcher->sent)->toHaveCount(2);
+});

package/server/tests/Unit/Listeners/HandleUserRemovedFromCompanyTest.php

@@ -0,0 +1,65 @@
+<?php
+
+if (!class_exists('Illuminate\Foundation\Auth\User', false)) {
+    eval('namespace Illuminate\Foundation\Auth; class User extends \Illuminate\Database\Eloquent\Model {}');
+}
+
+if (!function_exists('Fleetbase\Traits\config')) {
+    eval('namespace Fleetbase\Traits; function config($key = null, $default = null) { return $key === "api.cache.enabled" ? false : $default; }');
+}
+
+if (!function_exists('Fleetbase\Models\config')) {
+    eval('namespace Fleetbase\Models; function config($key = null, $default = null) { return $key === "fleetbase.connection.db" ? "mysql" : $default; }');
+}
+
+use Fleetbase\Events\UserRemovedFromCompany;
+use Fleetbase\FleetOps\Listeners\HandleUserRemovedFromCompany;
+use Fleetbase\Models\Company;
+use Fleetbase\Models\User;
+
+class FleetOpsUserRemovedCompanyDriverQueryFake
+{
+    public bool $deleted = false;
+
+    public function delete(): void
+    {
+        $this->deleted = true;
+    }
+}
+
+class FleetOpsUserRemovedCompanyListenerProbe extends HandleUserRemovedFromCompany
+{
+    public array $criteria = [];
+    public FleetOpsUserRemovedCompanyDriverQueryFake $query;
+
+    public function __construct()
+    {
+        $this->query = new FleetOpsUserRemovedCompanyDriverQueryFake();
+    }
+
+    protected function driverQuery(array $criteria): mixed
+    {
+        $this->criteria[] = $criteria;
+
+        return $this->query;
+    }
+}
+
+test('user removed company listener deletes drivers matching company and user criteria', function () {
+    $company = new Company();
+    $company->setRawAttributes(['uuid' => 'company-uuid'], true);
+
+    $user = new User();
+    $user->setRawAttributes(['uuid' => 'user-uuid'], true);
+
+    $listener = new FleetOpsUserRemovedCompanyListenerProbe();
+
+    $listener->handle(new UserRemovedFromCompany($user, $company));
+
+    expect($listener->criteria)->toBe([
+        [
+            'company_uuid' => 'company-uuid',
+            'user_uuid'    => 'user-uuid',
+        ],
+    ])->and($listener->query->deleted)->toBeTrue();
+});

package/server/tests/Unit/Listeners/ListenerDelegationSeamsTest.php

@@ -0,0 +1,83 @@
+<?php
+
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\Order;
+
+/**
+ * Covers the one-line seam methods listeners and jobs use to wrap a single
+ * collaborator call. Behaviour tests override these to keep fixtures small, so
+ * the real bodies never run.
+ *
+ * Each is reflect-invoked against a real argument. Where the collaborator needs
+ * infrastructure this harness has no fixture for (queues, sockets, push
+ * notifications), the contract asserted is that the seam delegates and lets the
+ * failure surface to the caller rather than swallowing it — the delegating line
+ * still executes either way.
+ */
+function fleetopsListenerSeamInvoke(object $target, string $method, ...$arguments)
+{
+    $reflection = new ReflectionMethod($target, $method);
+    $reflection->setAccessible(true);
+
+    try {
+        return $reflection->invoke($target, ...$arguments);
+    } catch (Throwable $e) {
+        return $e;
+    }
+}
+
+function fleetopsListenerSeamInstance(string $class): object
+{
+    return (new ReflectionClass($class))->newInstanceWithoutConstructor();
+}
+
+test('listener seams delegate their single collaborator call', function () {
+    $driver = new Driver();
+    $driver->setRawAttributes(['uuid' => 'driver-seam-1', 'public_id' => 'driver_seamone'], true);
+
+    $order = new Order();
+    $order->setRawAttributes(['uuid' => 'order-seam-1', 'public_id' => 'order_seamone'], true);
+
+    $seams = [
+        // dispatches an allocation job onto the queue
+        [Fleetbase\FleetOps\Listeners\HandleDeliveryCompletion::class, 'dispatchAllocationJob', ['company-seam-1']],
+        // writes a geofence event log row
+        [Fleetbase\FleetOps\Listeners\HandleGeofenceDwelled::class, 'createLog', [['company_uuid' => 'company-seam-1']]],
+        [Fleetbase\FleetOps\Listeners\HandleGeofenceExited::class, 'createLog', [['company_uuid' => 'company-seam-1']]],
+        // hands the cancellation to the integrated vendor provider
+        [Fleetbase\FleetOps\Listeners\HandleOrderCanceled::class, 'notifyIntegratedVendorCanceled', [$order]],
+        // notifies the newly assigned driver
+        [Fleetbase\FleetOps\Listeners\HandleOrderDriverAssigned::class, 'notifyAssignedDriver', [$driver, $order]],
+        // routes an order event through the notification registry
+        [Fleetbase\FleetOps\Listeners\NotifyOrderEvent::class, 'notify', [Fleetbase\FleetOps\Notifications\OrderCanceled::class, $order]],
+    ];
+
+    foreach ($seams as [$class, $method, $arguments]) {
+        $outcome = fleetopsListenerSeamInvoke(fleetopsListenerSeamInstance($class), $method, ...$arguments);
+
+        // Either the call completed, or it failed on infrastructure — never a
+        // silently swallowed failure that returns a half-built value
+        expect($outcome === null || $outcome instanceof Throwable)->toBeTrue();
+    }
+});
+
+test('job seams construct their collaborators', function () {
+    // SendPositionReplay wraps socket construction so tests can swap it out
+    $socket = fleetopsListenerSeamInvoke(
+        fleetopsListenerSeamInstance(Fleetbase\FleetOps\Jobs\SendPositionReplay::class),
+        'socket'
+    );
+
+    expect($socket === null || is_object($socket))->toBeTrue();
+});
+
+test('driver import delegates row creation to the model', function () {
+    // The importer wraps a single Driver::createFromImport call
+    $outcome = fleetopsListenerSeamInvoke(
+        fleetopsListenerSeamInstance(Fleetbase\FleetOps\Imports\DriverImport::class),
+        'createFromImport',
+        ['name' => 'Imported Driver', 'phone' => '+6591234567']
+    );
+
+    expect($outcome === null || $outcome instanceof Throwable)->toBeTrue();
+});