@fleetbase/fleetops-engine 0.6.71 → 0.6.72

package/server/tests/Unit/Observers/DriverDeletionCleanupTest.php

@@ -0,0 +1,158 @@
+<?php
+
+if (!function_exists('Fleetbase\\Observers\\event')) {
+    // The webhook observer announces each deletion; only the cleanup matters here
+    eval('namespace Fleetbase\Observers; function event($event = null, $payload = []) { return []; }');
+}
+
+// The lifecycle event the webhook observer builds names the model with a core-api macro
+if (!Illuminate\Support\Str::hasMacro('humanize')) {
+    Illuminate\Support\Str::macro('humanize', fn ($value, $uppercase = true) => str_replace('_', ' ', Illuminate\Support\Str::snake((string) $value)));
+}
+
+use Fleetbase\Events\UserRemovedFromCompany;
+use Fleetbase\FleetOps\Listeners\HandleUserRemovedFromCompany;
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Observers\CompanyUserObserver;
+use Fleetbase\FleetOps\Observers\DriverObserver;
+use Fleetbase\FleetOps\Observers\UserObserver;
+use Fleetbase\Models\Company;
+use Fleetbase\Models\CompanyUser;
+use Fleetbase\Models\User;
+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\Events\Dispatcher;
+use Illuminate\Support\Facades\Cache;
+
+/**
+ * Drivers removed along with their user or company membership go through
+ * Driver::delete(), so DriverObserver unassigns their orders and releases
+ * their managed login account.
+ */
+beforeEach(function () {
+    Cache::swap(new Repository(new ArrayStore()));
+    session(['company' => 'co-1']);
+});
+
+afterEach(function () {
+    EloquentModel::unsetConnectionResolver();
+    EloquentModel::unsetEventDispatcher();
+});
+
+function driverDeletionCleanupDatabase(): SQLiteConnection
+{
+    $db     = TrackingPageDatabase::boot();
+    $schema = $db->getSchemaBuilder();
+
+    $schema->create('users', function ($table) {
+        $table->increments('id');
+        $table->string('uuid')->nullable();
+        $table->string('public_id')->nullable();
+        $table->string('company_uuid')->nullable();
+        $table->string('type')->nullable();
+        $table->timestamps();
+        $table->softDeletes();
+    });
+    $schema->create('company_users', function ($table) {
+        $table->increments('id');
+        $table->string('uuid')->nullable();
+        $table->string('company_uuid')->nullable();
+        $table->string('user_uuid')->nullable();
+        $table->string('status')->nullable();
+        $table->timestamps();
+        $table->softDeletes();
+    });
+    $schema->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();
+    });
+
+    // Model hooks bind to the dispatcher present when a class boots
+    EloquentModel::setEventDispatcher(new Dispatcher());
+    EloquentModel::clearBootedModels();
+    Driver::observe(DriverObserver::class);
+    // Core models clear the HTTP response cache on writes, and log activity
+    app()->instance('responsecache', new class {
+        public function __call($method, $arguments)
+        {
+            return null;
+        }
+    });
+    config()->set('activitylog.enabled', false);
+    app()->bind(Illuminate\Contracts\Config\Repository::class, fn () => config());
+
+    TrackingPageDatabase::insert($db, 'users', ['uuid' => 'user-1', 'type' => 'driver']);
+    TrackingPageDatabase::insert($db, 'users', ['uuid' => 'user-2', 'type' => 'driver']);
+    TrackingPageDatabase::insert($db, 'company_users', ['uuid' => 'cu-1', 'company_uuid' => 'co-1', 'user_uuid' => 'user-1', 'status' => 'active']);
+    TrackingPageDatabase::insert($db, 'drivers', ['uuid' => 'driver-1', 'company_uuid' => 'co-1', 'user_uuid' => 'user-1']);
+    TrackingPageDatabase::insert($db, 'drivers', ['uuid' => 'driver-2', 'company_uuid' => 'co-1', 'user_uuid' => 'user-2']);
+    TrackingPageDatabase::insert($db, 'orders', ['uuid' => 'order-1', 'company_uuid' => 'co-1', 'driver_assigned_uuid' => 'driver-1']);
+    TrackingPageDatabase::insert($db, 'orders', ['uuid' => 'order-2', 'company_uuid' => 'co-1', 'driver_assigned_uuid' => 'driver-2']);
+
+    return $db;
+}
+
+function driverDeletionCleanupState(SQLiteConnection $db): array
+{
+    return [
+        'drivers' => $db->table('drivers')->whereNull('deleted_at')->orderBy('uuid')->pluck('uuid')->all(),
+        'orders'  => $db->table('orders')->orderBy('uuid')->pluck('driver_assigned_uuid', 'uuid')->all(),
+        'users'   => $db->table('users')->whereNull('deleted_at')->orderBy('uuid')->pluck('uuid')->all(),
+    ];
+}
+
+test('deleting a user deletes their drivers through the model so their orders are unassigned', function () {
+    $db = driverDeletionCleanupDatabase();
+    TrackingPageDatabase::insert($db, 'drivers', ['uuid' => 'driver-1-other', 'company_uuid' => 'co-2', 'user_uuid' => 'user-1']);
+
+    // The user is already soft-deleted when its deleted event fires
+    $db->table('users')->where('uuid', 'user-1')->update(['deleted_at' => now()]);
+    $user = User::withTrashed()->where('uuid', 'user-1')->first();
+
+    (new UserObserver())->deleted($user);
+
+    expect(driverDeletionCleanupState($db))->toBe([
+        'drivers' => ['driver-2'],
+        'orders'  => ['order-1' => null, 'order-2' => 'driver-2'],
+        'users'   => ['user-2'],
+    ]);
+});
+
+test('deleting a company user deletes its driver through the model and releases the managed account', function () {
+    $db = driverDeletionCleanupDatabase();
+
+    $companyUser = CompanyUser::where('uuid', 'cu-1')->first();
+    $companyUser->delete();
+
+    (new CompanyUserObserver())->deleted($companyUser);
+
+    expect(driverDeletionCleanupState($db))->toBe([
+        'drivers' => ['driver-2'],
+        'orders'  => ['order-1' => null, 'order-2' => 'driver-2'],
+        'users'   => ['user-2'],
+    ]);
+});
+
+test('removing a user from a company deletes its driver through the model', function () {
+    $db = driverDeletionCleanupDatabase();
+
+    $company = new Company();
+    $company->setRawAttributes(['uuid' => 'co-1'], true);
+
+    (new HandleUserRemovedFromCompany())->handle(new UserRemovedFromCompany(User::where('uuid', 'user-1')->first(), $company));
+
+    expect(driverDeletionCleanupState($db))->toBe([
+        'drivers' => ['driver-2'],
+        'orders'  => ['order-1' => null, 'order-2' => 'driver-2'],
+        'users'   => ['user-2'],
+    ]);
+});

package/server/tests/Unit/Observers/FleetOpsCompanyUserAndServiceAreaObserversTest.php

@@ -104,6 +104,26 @@ test('company user status changes sync onto the driver record', function () {
     expect($connection->table('drivers')->value('status'))->toBe('suspended');
 });
 
+test('company user changes only touch the driver profile in that company', function () {
+    $connection = fleetopsObserversBoot();
+    $connection->table('users')->insert(['uuid' => 'user-1', 'company_uuid' => 'company-1']);
+    $connection->table('drivers')->insert([
+        ['uuid' => 'driver-other', 'company_uuid' => 'company-2', 'user_uuid' => 'user-1', 'status' => 'active'],
+        ['uuid' => 'driver-1', 'company_uuid' => 'company-1', 'user_uuid' => 'user-1', 'status' => 'active'],
+    ]);
+
+    $companyUser         = fleetopsObserversCompanyUser();
+    $companyUser->status = 'suspended';
+    $companyUser->syncChanges();
+    (new CompanyUserObserver())->updated($companyUser);
+
+    expect($connection->table('drivers')->pluck('status', 'uuid')->all())->toBe(['driver-other' => 'active', 'driver-1' => 'suspended']);
+
+    (new CompanyUserObserver())->deleted($companyUser);
+
+    expect($connection->table('drivers')->whereNull('deleted_at')->pluck('uuid')->all())->toBe(['driver-other']);
+});
+
 test('service area deletion cascades to zones and border derives from country', function () {
     $connection = fleetopsObserversBoot();
     $connection->table('zones')->insert(['uuid' => 'zone-1', 'company_uuid' => 'company-1', 'service_area_uuid' => 'sa-1', 'name' => 'Zone 1']);

package/server/tests/Unit/Observers/ObserverListenerSeamsTest.php

@@ -142,12 +142,12 @@ test('vehicle observer seams resolve drivers and release assignments', function
     expect(fleetopsObserverSeamInvoke(Fleetbase\FleetOps\Observers\VehicleObserver::class, 'findDriver', ['driver-veh-1'])?->uuid)->toBe('driver-veh-1')
         ->and(fleetopsObserverSeamInvoke(Fleetbase\FleetOps\Observers\VehicleObserver::class, 'findDriver', ['driver-missing']))->toBeNull();
 
-    // Deleting a vehicle releases only the drivers assigned to it
+    // Deleting a vehicle unassigns only the drivers assigned to it, and keeps them
     $vehicle = new Vehicle();
     $vehicle->setRawAttributes(['uuid' => 'vehicle-seam-1'], true);
-    fleetopsObserverSeamInvoke(Fleetbase\FleetOps\Observers\VehicleObserver::class, 'deleteDriversAssignedTo', [$vehicle]);
+    fleetopsObserverSeamInvoke(Fleetbase\FleetOps\Observers\VehicleObserver::class, 'unassignDriversFrom', [$vehicle]);
 
-    expect($connection->table('drivers')->whereNull('deleted_at')->pluck('uuid')->all())->toBe(['driver-veh-2']);
+    expect($connection->table('drivers')->whereNull('deleted_at')->pluck('vehicle_uuid', 'uuid')->all())->toBe(['driver-veh-1' => null, 'driver-veh-2' => 'vehicle-other']);
 });
 
 test('fleet observer clears the parent reference from child fleets', function () {

package/server/tests/Unit/Observers/OrderAssignmentObserverTest.php

@@ -0,0 +1,100 @@
+<?php
+
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Observers\OrderObserver;
+use Fleetbase\FleetOps\Support\TrackingPublisher;
+use Illuminate\Cache\ArrayStore;
+use Illuminate\Cache\Repository;
+use Illuminate\Support\Facades\Cache;
+
+/**
+ * Covers how the order observer follows driver assignment: a replaced driver is
+ * told they were unassigned, and the new driver is notified exactly once (and not
+ * at all for a silent assignment).
+ */
+class FleetOpsOrderAssignmentObserverOrder extends Order
+{
+    public array $events       = [];
+    public array $originalData = [];
+    public bool $driverChanged = true;
+    public bool $driverDirty   = false;
+
+    public function getOriginal($key = null, $default = null): mixed
+    {
+        return $key === null ? $this->originalData : ($this->originalData[$key] ?? $default);
+    }
+
+    public function wasChanged($attributes = null): bool
+    {
+        return $attributes === 'driver_assigned_uuid' && $this->driverChanged;
+    }
+
+    public function isDirty($attributes = null): bool
+    {
+        return $attributes === 'driver_assigned_uuid' && $this->driverDirty;
+    }
+
+    public function setDriverLocationAsPickup($force = false)
+    {
+    }
+
+    public function notifyDriverAssigned()
+    {
+        $this->events[] = 'assigned:' . $this->driver_assigned_uuid;
+    }
+
+    public function notifyDriverUnassigned($driver): bool
+    {
+        $this->events[] = 'unassigned:' . $driver;
+
+        return true;
+    }
+}
+
+beforeEach(function () {
+    Cache::swap(new Repository(new ArrayStore()));
+    session(['company' => 'company-uuid']);
+
+    // public tracking is published elsewhere; it is not what these tests cover
+    app()->instance(TrackingPublisher::class, new class extends TrackingPublisher {
+        public function orderChanged(Order $order): bool
+        {
+            return false;
+        }
+    });
+});
+
+test('reassigning an order tells the replaced driver and notifies the new one once', function () {
+    $order = new FleetOpsOrderAssignmentObserverOrder();
+    $order->setRawAttributes(['uuid' => 'order-uuid', 'driver_assigned_uuid' => 'driver-new'], true);
+    $order->originalData = ['driver_assigned_uuid' => 'driver-old'];
+
+    (new OrderObserver())->updated($order);
+
+    expect($order->events)->toBe(['unassigned:driver-old', 'assigned:driver-new']);
+});
+
+test('unassigning tells the driver and a silent assignment sends no assignment notification', function () {
+    $unassigned = new FleetOpsOrderAssignmentObserverOrder();
+    $unassigned->setRawAttributes(['uuid' => 'order-uuid', 'driver_assigned_uuid' => null], true);
+    $unassigned->originalData = ['driver_assigned_uuid' => 'driver-old'];
+
+    (new OrderObserver())->updated($unassigned);
+
+    $silent = new FleetOpsOrderAssignmentObserverOrder();
+    $silent->setRawAttributes(['uuid' => 'order-uuid', 'driver_assigned_uuid' => 'driver-new'], true);
+    $silent->silentDriverAssignment = true;
+
+    (new OrderObserver())->updated($silent);
+
+    expect($unassigned->events)->toBe(['unassigned:driver-old', 'assigned:'])
+        ->and($silent->events)->toBe([]);
+});
+
+test('assign driver relies on the observer instead of notifying before the save', function () {
+    $source = file_get_contents(dirname(__DIR__, 3) . '/src/Models/Order.php');
+    preg_match('/public function assignDriver\(.*?\n    }\n/s', $source, $matches);
+
+    expect($matches[0] ?? '')->not->toContain('notifyDriverAssigned()')
+        ->toContain('$this->silentDriverAssignment = (bool) $silent;');
+});

package/server/tests/Unit/Observers/OrderDeleteCascadeTest.php

@@ -0,0 +1,213 @@
+<?php
+
+use Fleetbase\FleetOps\Models\Entity;
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Models\Waypoint;
+use Fleetbase\FleetOps\Observers\OrderObserver;
+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\Carbon;
+use Illuminate\Support\Facades\Cache;
+
+class OrderDeleteCascadeBulkProbe extends Order
+{
+    protected $table = 'orders';
+
+    public static array $deleted = [];
+
+    public function delete()
+    {
+        static::$deleted[] = $this->uuid;
+
+        return parent::delete();
+    }
+}
+
+beforeEach(function () {
+    Cache::swap(new Repository(new ArrayStore()));
+    session(['company' => 'co-1']);
+    OrderDeleteCascadeBulkProbe::$deleted = [];
+});
+
+afterEach(function () {
+    Carbon::setTestNow();
+    EloquentModel::unsetConnectionResolver();
+});
+
+function orderDeleteCascadeFixture(): SQLiteConnection
+{
+    $db = TrackingPageDatabase::boot();
+
+    $rows = [
+        'orders' => [
+            ['uuid' => 'order-1', 'public_id' => 'order_one', 'company_uuid' => 'co-1', 'payload_uuid' => 'payload-1', 'tracking_number_uuid' => 'tn-order'],
+            ['uuid' => 'order-shared-a', 'public_id' => 'order_shared_a', 'company_uuid' => 'co-1', 'payload_uuid' => 'payload-shared', 'tracking_number_uuid' => 'tn-shared-a'],
+            ['uuid' => 'order-shared-b', 'public_id' => 'order_shared_b', 'company_uuid' => 'co-1', 'payload_uuid' => 'payload-shared'],
+            ['uuid' => 'order-bare', 'public_id' => 'order_bare', 'company_uuid' => 'co-1'],
+            ['uuid' => 'order-other', 'public_id' => 'order_other', 'company_uuid' => 'co-2', 'payload_uuid' => 'payload-other'],
+        ],
+        'payloads' => [
+            ['uuid' => 'payload-1', 'dropoff_tracking_number_uuid' => 'tn-dropoff'],
+            ['uuid' => 'payload-shared'],
+            ['uuid' => 'payload-other'],
+        ],
+        'entities' => [
+            ['uuid' => 'entity-1', 'payload_uuid' => 'payload-1', 'tracking_number_uuid' => 'tn-entity'],
+            ['uuid' => 'entity-owned', 'payload_uuid' => 'payload-1'],
+            ['uuid' => 'entity-gone', 'payload_uuid' => 'payload-1', 'deleted_at' => '2026-01-01 00:00:00'],
+            ['uuid' => 'entity-shared', 'payload_uuid' => 'payload-shared'],
+        ],
+        'waypoints' => [
+            ['uuid' => 'wp-1', 'payload_uuid' => 'payload-1', 'tracking_number_uuid' => 'tn-waypoint'],
+        ],
+        'tracking_numbers' => [
+            ['uuid' => 'tn-order', 'owner_uuid' => 'order-1', 'owner_type' => Order::class],
+            ['uuid' => 'tn-entity', 'owner_uuid' => 'entity-1', 'owner_type' => Entity::class],
+            ['uuid' => 'tn-entity-owned', 'owner_uuid' => 'entity-owned', 'owner_type' => Entity::class],
+            ['uuid' => 'tn-waypoint', 'owner_uuid' => 'wp-1', 'owner_type' => Waypoint::class],
+            ['uuid' => 'tn-dropoff', 'owner_uuid' => 'place-dropoff'],
+            ['uuid' => 'tn-shared-a', 'owner_uuid' => 'order-shared-a', 'owner_type' => Order::class],
+            ['uuid' => 'tn-unrelated', 'owner_uuid' => 'order-other', 'owner_type' => Order::class],
+        ],
+        'tracking_statuses' => [
+            ['uuid' => 'ts-order', 'tracking_number_uuid' => 'tn-order'],
+            ['uuid' => 'ts-entity', 'tracking_number_uuid' => 'tn-entity-owned'],
+            ['uuid' => 'ts-shared-a', 'tracking_number_uuid' => 'tn-shared-a'],
+            ['uuid' => 'ts-unrelated', 'tracking_number_uuid' => 'tn-unrelated'],
+        ],
+    ];
+
+    foreach ($rows as $table => $records) {
+        foreach ($records as $record) {
+            TrackingPageDatabase::insert($db, $table, $record);
+        }
+    }
+
+    return $db;
+}
+
+function orderDeleteCascadeDeletedAt(SQLiteConnection $db, string $table, string $uuid): ?string
+{
+    return $db->table($table)->where('uuid', $uuid)->value('deleted_at');
+}
+
+function orderDeleteCascadeSoftDelete(SQLiteConnection $db, string $uuid): Order
+{
+    $db->table('orders')->where('uuid', $uuid)->update(['deleted_at' => now()->toDateTimeString()]);
+
+    return Order::withTrashed()->where('uuid', $uuid)->first();
+}
+
+test('deleting an order soft-deletes its payload tree and tracking data with the order timestamp', function () {
+    Carbon::setTestNow('2026-10-09 12:00:00');
+    $db    = orderDeleteCascadeFixture();
+    $order = orderDeleteCascadeSoftDelete($db, 'order-1');
+
+    (new OrderObserver())->deleted($order);
+
+    $stamp = '2026-10-09 12:00:00';
+    foreach ([
+        ['payloads', 'payload-1'],
+        ['entities', 'entity-1'],
+        ['entities', 'entity-owned'],
+        ['waypoints', 'wp-1'],
+        ['tracking_numbers', 'tn-order'],
+        ['tracking_numbers', 'tn-entity'],
+        ['tracking_numbers', 'tn-entity-owned'],
+        ['tracking_numbers', 'tn-waypoint'],
+        ['tracking_numbers', 'tn-dropoff'],
+        ['tracking_statuses', 'ts-order'],
+        ['tracking_statuses', 'ts-entity'],
+    ] as [$table, $uuid]) {
+        expect(orderDeleteCascadeDeletedAt($db, $table, $uuid))->toBe($stamp, "{$table}.{$uuid}");
+    }
+
+    // Rows outside the order, and children deleted earlier, keep their state.
+    expect(orderDeleteCascadeDeletedAt($db, 'entities', 'entity-gone'))->toBe('2026-01-01 00:00:00')
+        ->and(orderDeleteCascadeDeletedAt($db, 'tracking_numbers', 'tn-unrelated'))->toBeNull()
+        ->and(orderDeleteCascadeDeletedAt($db, 'tracking_statuses', 'ts-unrelated'))->toBeNull()
+        ->and(orderDeleteCascadeDeletedAt($db, 'payloads', 'payload-other'))->toBeNull()
+        ->and(Cache::get('live:co-1:orders:version'))->toBe(1);
+});
+
+test('restoring an order brings back only the children deleted with it', function () {
+    Carbon::setTestNow('2026-10-09 12:00:00');
+    $db       = orderDeleteCascadeFixture();
+    $order    = orderDeleteCascadeSoftDelete($db, 'order-1');
+    $observer = new OrderObserver();
+    $observer->deleted($order);
+
+    // An entity deleted on its own after the order keeps its own timestamp.
+    $db->table('entities')->insert(['uuid' => 'entity-later', 'payload_uuid' => 'payload-1', 'deleted_at' => '2026-10-10 08:00:00']);
+
+    $observer->restoring($order);
+    $db->table('orders')->where('uuid', 'order-1')->update(['deleted_at' => null]);
+    $order->deleted_at = null;
+    $observer->restored($order);
+
+    foreach ([
+        ['payloads', 'payload-1'],
+        ['entities', 'entity-1'],
+        ['entities', 'entity-owned'],
+        ['waypoints', 'wp-1'],
+        ['tracking_numbers', 'tn-order'],
+        ['tracking_numbers', 'tn-entity'],
+        ['tracking_numbers', 'tn-entity-owned'],
+        ['tracking_numbers', 'tn-waypoint'],
+        ['tracking_numbers', 'tn-dropoff'],
+        ['tracking_statuses', 'ts-order'],
+        ['tracking_statuses', 'ts-entity'],
+    ] as [$table, $uuid]) {
+        expect(orderDeleteCascadeDeletedAt($db, $table, $uuid))->toBeNull("{$table}.{$uuid}");
+    }
+
+    expect(orderDeleteCascadeDeletedAt($db, 'entities', 'entity-gone'))->toBe('2026-01-01 00:00:00')
+        ->and(orderDeleteCascadeDeletedAt($db, 'entities', 'entity-later'))->toBe('2026-10-10 08:00:00');
+
+    // A second "restored" without a matching "restoring" has nothing to restore.
+    $db->table('tracking_numbers')->where('uuid', 'tn-order')->update(['deleted_at' => '2026-10-09 12:00:00']);
+    $observer->restored($order);
+    $observer->restoring($order);
+
+    expect(orderDeleteCascadeDeletedAt($db, 'tracking_numbers', 'tn-order'))->toBe('2026-10-09 12:00:00');
+});
+
+test('a payload shared with another live order is left alone', function () {
+    Carbon::setTestNow('2026-10-09 12:00:00');
+    $db    = orderDeleteCascadeFixture();
+    $order = orderDeleteCascadeSoftDelete($db, 'order-shared-a');
+
+    (new OrderObserver())->deleted($order);
+
+    expect(orderDeleteCascadeDeletedAt($db, 'payloads', 'payload-shared'))->toBeNull()
+        ->and(orderDeleteCascadeDeletedAt($db, 'entities', 'entity-shared'))->toBeNull()
+        ->and(orderDeleteCascadeDeletedAt($db, 'tracking_numbers', 'tn-shared-a'))->toBe('2026-10-09 12:00:00')
+        ->and(orderDeleteCascadeDeletedAt($db, 'tracking_statuses', 'ts-shared-a'))->toBe('2026-10-09 12:00:00');
+
+    // An order without a payload or deletion timestamp (force delete) still cascades cleanly.
+    $bare = Order::where('uuid', 'order-bare')->first();
+    (new OrderObserver())->deleted($bare);
+
+    expect(orderDeleteCascadeDeletedAt($db, 'payloads', 'payload-other'))->toBeNull();
+});
+
+test('bulk removal deletes each matched order of the session company one by one', function () {
+    $db = orderDeleteCascadeFixture();
+
+    $count = (new OrderDeleteCascadeBulkProbe())->bulkRemove(['order-1', 'order_bare', 'order-other']);
+
+    expect($count)->toBe(2)
+        ->and(OrderDeleteCascadeBulkProbe::$deleted)->toBe(['order-1', 'order-bare'])
+        ->and(orderDeleteCascadeDeletedAt($db, 'orders', 'order-1'))->not->toBeNull()
+        ->and(orderDeleteCascadeDeletedAt($db, 'orders', 'order-other'))->toBeNull();
+
+    // Without a session company the lookup is not tenant constrained, like core-api's.
+    session(['company' => null]);
+    OrderDeleteCascadeBulkProbe::$deleted = [];
+
+    expect((new OrderDeleteCascadeBulkProbe())->bulkRemove(['order-other']))->toBe(1)
+        ->and(OrderDeleteCascadeBulkProbe::$deleted)->toBe(['order-other']);
+});

package/server/tests/Unit/Observers/VehicleObserverDeleteTest.php

@@ -0,0 +1,67 @@
+<?php
+
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Observers\VehicleObserver;
+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 vehicleObserverDeleteDatabase(): 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('company_uuid')->nullable();
+        $table->string('user_uuid')->nullable();
+        $table->string('vehicle_uuid')->nullable();
+        $table->timestamps();
+        $table->softDeletes();
+    });
+
+    foreach (['user-1', 'user-2', 'user-3'] 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', 'vehicle_uuid' => 'vehicle-1']);
+    TrackingPageDatabase::insert($db, 'drivers', ['uuid' => 'driver-3', 'company_uuid' => 'co-1', 'user_uuid' => 'user-3', 'vehicle_uuid' => 'vehicle-2']);
+
+    return $db;
+}
+
+test('deleting a vehicle unassigns its drivers without deleting them', function () {
+    $db = vehicleObserverDeleteDatabase();
+
+    $vehicle = new Vehicle();
+    $vehicle->setRawAttributes(['uuid' => 'vehicle-1', 'company_uuid' => 'co-1'], true);
+
+    (new VehicleObserver())->deleted($vehicle);
+
+    $drivers = $db->table('drivers')->orderBy('uuid')->get(['uuid', 'vehicle_uuid', 'deleted_at'])->map(fn ($row) => (array) $row)->all();
+
+    expect($drivers)->toBe([
+        ['uuid' => 'driver-1', 'vehicle_uuid' => null, 'deleted_at' => null],
+        ['uuid' => 'driver-2', 'vehicle_uuid' => null, 'deleted_at' => null],
+        ['uuid' => 'driver-3', 'vehicle_uuid' => 'vehicle-2', 'deleted_at' => null],
+    ]);
+});