@fleetbase/fleetops-engine 0.6.58 → 0.6.59

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

@@ -0,0 +1,73 @@
+<?php
+
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Models\Waypoint;
+use Fleetbase\FleetOps\Notifications\OrderFailed;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+/**
+ * Covers the OrderFailed notification: title/message construction with the
+ * waypoint tracking-number preference, broadcast channel construction, and
+ * the fcm/apn push delegation seams.
+ */
+function fleetopsOrderFailedBoot(): void
+{
+    $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
+    $resolver   = new ConnectionResolver(['default' => $connection, 'mysql' => $connection]);
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+
+    session(['company' => 'company-1', 'api_credential' => 'console']);
+}
+
+function fleetopsOrderFailedOrder(): Order
+{
+    $order = new Order();
+    $order->setRawAttributes([
+        'uuid'      => 'order-1',
+        'public_id' => 'order_test',
+        'status'    => 'failed',
+    ], true);
+    $order->exists = true;
+
+    return $order;
+}
+
+test('order failed builds title and data with waypoint tracking preference', function () {
+    fleetopsOrderFailedBoot();
+
+    $notification = new OrderFailed(fleetopsOrderFailedOrder(), 'address unreachable');
+    expect($notification->title)->toContain('delivery has')
+        ->and($notification->data)->toBe(['id' => 'order_test', 'type' => 'order_canceled']);
+
+    $waypoint = new Waypoint();
+    $waypoint->setRawAttributes(['uuid' => 'wp-1'], true);
+    $trackingNumber = new Fleetbase\FleetOps\Models\TrackingNumber();
+    $trackingNumber->setRawAttributes(['uuid' => 'tn-1', 'tracking_number' => 'WPTRK-7'], true);
+    $waypoint->setRelation('trackingNumber', $trackingNumber);
+    $withWaypoint = new OrderFailed(fleetopsOrderFailedOrder(), 'address unreachable', $waypoint);
+    expect($withWaypoint->title)->toContain('WPTRK-7');
+});
+
+test('order failed broadcasts on company api and order channels', function () {
+    fleetopsOrderFailedBoot();
+
+    $channels = (new OrderFailed(fleetopsOrderFailedOrder(), 'reason'))->broadcastOn();
+
+    expect($channels)->toHaveCount(5)
+        ->and($channels[2]->name)->toBe('api.console')
+        ->and($channels[3]->name)->toBe('order.order-1')
+        ->and($channels[4]->name)->toBe('order.order_test');
+});
+
+test('order failed push channel seams execute their delegation bodies', function () {
+    fleetopsOrderFailedBoot();
+    $notification = new OrderFailed(fleetopsOrderFailedOrder(), 'reason');
+
+    // 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/OrderPingChannelsTest.php

@@ -0,0 +1,69 @@
+<?php
+
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Notifications\OrderPing;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Notifications\Messages\BroadcastMessage;
+
+/**
+ * Covers the OrderPing notification's broadcast payload construction and the
+ * push channel seams. The broadcast message serializes the order resource and
+ * transforms child resources to ids; the fcm/apn seams execute their real
+ * delegation bodies, which require push transport packages unavailable in the
+ * harness.
+ */
+function fleetopsOrderPingBoot(): void
+{
+    $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
+    $resolver   = new ConnectionResolver(['default' => $connection, 'mysql' => $connection]);
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+}
+
+function fleetopsOrderPingOrder(): Order
+{
+    $order = new Order();
+    $order->setRawAttributes([
+        'uuid'      => 'order-1',
+        'public_id' => 'order_test',
+        'status'    => 'created',
+    ], true);
+    $order->exists = true;
+
+    return $order;
+}
+
+test('order ping builds title message and data from the order and distance', function () {
+    fleetopsOrderPingBoot();
+
+    $withDistance = new OrderPing(fleetopsOrderPingOrder(), 1500);
+    expect($withDistance->title)->toBe('New incoming order!')
+        ->and($withDistance->message)->toContain('away')
+        ->and($withDistance->data)->toBe(['id' => 'order_test', 'type' => 'order_ping']);
+
+    $withoutDistance = new OrderPing(fleetopsOrderPingOrder());
+    expect($withoutDistance->message)->toBe('New order is available for pickup.');
+});
+
+test('order ping broadcast message wraps the serialized order resource', function () {
+    fleetopsOrderPingBoot();
+
+    $broadcast = (new OrderPing(fleetopsOrderPingOrder(), 250))->toBroadcast(null);
+
+    expect($broadcast)->toBeInstanceOf(BroadcastMessage::class)
+        ->and($broadcast->data['event'])->toBe('order.ping')
+        ->and($broadcast->data['id'])->toStartWith('event_')
+        ->and($broadcast->data)->toHaveKeys(['api_version', 'created_at', 'data']);
+});
+
+test('order ping push channel seams execute their delegation bodies', function () {
+    fleetopsOrderPingBoot();
+    $ping = new OrderPing(fleetopsOrderPingOrder());
+
+    // The fcm/apn transport packages are unavailable in the harness; the
+    // delegation bodies still execute, which is the covered contract here.
+    expect(fn () => $ping->toFcm(null))->toThrow(Exception::class)
+        ->and(fn () => $ping->toApn(null))->toThrow(Error::class);
+});

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

@@ -0,0 +1,185 @@
+<?php
+
+if (!function_exists('config')) {
+    function config($key = null, $default = null)
+    {
+        static $values = [];
+
+        if (is_array($key)) {
+            $values = array_merge($values, $key);
+
+            return null;
+        }
+
+        return $values[$key] ?? $default;
+    }
+}
+
+if (!function_exists('session')) {
+    function session($key = null, $default = null)
+    {
+        static $values = [];
+
+        if (is_array($key)) {
+            $values = array_merge($values, $key);
+
+            return null;
+        }
+
+        if ($key === null) {
+            return new class($values) {
+                public function __construct(private array $values)
+                {
+                }
+
+                public function missing($key): bool
+                {
+                    return !array_key_exists($key, $this->values);
+                }
+            };
+        }
+
+        return $values[$key] ?? $default;
+    }
+}
+
+if (!function_exists('Fleetbase\Traits\config')) {
+    eval('namespace Fleetbase\Traits; function config($key = null, $default = null) { return \config($key, $default); }');
+}
+
+if (!function_exists('Fleetbase\Support\app')) {
+    eval('namespace Fleetbase\Support; function app($abstract = null) { return $abstract ? \Illuminate\Container\Container::getInstance()->make($abstract) : \Illuminate\Container\Container::getInstance(); }');
+}
+
+if (!function_exists('Fleetbase\Support\config')) {
+    eval('namespace Fleetbase\Support; function config($key = null, $default = null) { return match ($key) { "fleetbase.console.host" => "console.fleetbase.test", "fleetbase.console.secure" => true, "fleetbase.console.subdomain" => null, default => \config($key, $default) }; }');
+}
+
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Models\Waypoint;
+use Fleetbase\FleetOps\Notifications\OrderCompleted;
+use Fleetbase\FleetOps\Notifications\OrderDispatched;
+use Fleetbase\FleetOps\Notifications\OrderFailed;
+use Illuminate\Container\Container;
+
+class FleetOpsTerminalNotificationOrderFake extends Order
+{
+    public string $uuid      = 'order-uuid';
+    public string $public_id = 'order_public';
+    public string $tracking  = 'ORDER-TRACK';
+}
+
+function fleetopsTerminalNotificationOrder(): Order
+{
+    $order = new FleetOpsTerminalNotificationOrderFake();
+    $order->setRelation('company', (object) [
+        'uuid'      => 'company-uuid',
+        'public_id' => 'company-public',
+    ]);
+
+    return $order;
+}
+
+function fleetopsTerminalNotificationWaypoint(string $tracking = 'WP-TRACK'): Waypoint
+{
+    $waypoint = new Waypoint();
+    $waypoint->setRawAttributes([
+        'uuid'      => 'waypoint-uuid',
+        'public_id' => 'waypoint_public',
+        'tracking'  => $tracking,
+    ], true);
+    $waypoint->setRelation('trackingNumber', (object) [
+        'tracking_number' => $tracking,
+    ]);
+
+    return $waypoint;
+}
+
+function fleetopsTerminalNotificationWithConsoleConfig(callable $callback): mixed
+{
+    $previousApp = Container::getInstance();
+    $app         = new class extends Container {
+        public function environment(...$environments)
+        {
+            return false;
+        }
+    };
+
+    if ($previousApp->bound('config')) {
+        $app->instance('config', $previousApp->make('config'));
+    }
+
+    Container::setInstance($app);
+
+    try {
+        return $callback();
+    } finally {
+        Container::setInstance($previousApp);
+    }
+}
+
+test('completed order notification formats mail and array payloads from order tracking fallback', function () {
+    session([
+        'company'        => 'company-session',
+        'api_credential' => 'api-credential',
+    ]);
+
+    $notification = new OrderCompleted(fleetopsTerminalNotificationOrder());
+    $mail         = fleetopsTerminalNotificationWithConsoleConfig(fn () => $notification->toMail(null));
+
+    expect($notification->title)->toBe('Order ORDER-TRACK has been completed.')
+        ->and($notification->message)->toBe('Order ORDER-TRACK has been completed by agent.')
+        ->and($notification->data)->toBe(['id' => 'order_public', 'type' => 'order_completed'])
+        ->and($notification->toArray())->toMatchArray([
+            'event' => 'order.completed_notification',
+            'title' => 'Order ORDER-TRACK has been completed.',
+            'body'  => 'Order ORDER-TRACK has been completed by agent.',
+        ])
+        ->and($mail->subject)->toBe('Order ORDER-TRACK has been completed.')
+        ->and($mail->introLines)->toContain(
+            'Order ORDER-TRACK has been completed by agent.',
+            'No further action is necessary.'
+        )
+        ->and($mail->actionText)->toBe('Track Order')
+        ->and($mail->actionUrl)->toContain('order=ORDER-TRACK');
+});
+
+test('failed order notification formats mail and array payloads from waypoint tracking', function () {
+    $order        = fleetopsTerminalNotificationOrder();
+    $waypoint     = fleetopsTerminalNotificationWaypoint('WP-FAILED');
+    $notification = new OrderFailed($order, 'recipient unavailable', $waypoint);
+    $mail         = fleetopsTerminalNotificationWithConsoleConfig(fn () => $notification->toMail(null));
+
+    expect($notification->title)->toBe('Order WP-FAILED delivery has has failed')
+        ->and($notification->message)->toBe('Order WP-FAILED delivery has failed.')
+        ->and($notification->reason)->toBe('recipient unavailable')
+        ->and($notification->data)->toBe(['id' => 'order_public', 'type' => 'order_canceled'])
+        ->and($notification->toArray())->toMatchArray([
+            'event' => 'order.failed_notification',
+            'title' => 'Order WP-FAILED delivery has has failed',
+            'body'  => 'Order WP-FAILED delivery has failed. recipient unavailable',
+        ])
+        ->and($mail->subject)->toBe('Order WP-FAILED delivery has has failed')
+        ->and($mail->introLines)->toContain(
+            'Order WP-FAILED delivery has failed.',
+            'recipient unavailable',
+            'No further action is necessary.'
+        )
+        ->and($mail->actionText)->toBe('Track Order')
+        ->and($mail->actionUrl)->toContain('order=WP-FAILED');
+});
+
+test('dispatched order notification formats mail from waypoint tracking fallback', function () {
+    $order        = fleetopsTerminalNotificationOrder();
+    $waypoint     = fleetopsTerminalNotificationWaypoint('WP-DISPATCHED');
+    $notification = new OrderDispatched($order, $waypoint);
+    $mail         = fleetopsTerminalNotificationWithConsoleConfig(fn () => $notification->toMail(null));
+
+    expect($notification->title)->toBe('Order WP-DISPATCHED has been dispatched!')
+        ->and($notification->message)->toBe('An order has just been dispatched to you and is ready to be started.')
+        ->and($notification->data)->toBe(['id' => 'order_public', 'type' => 'order_dispatched'])
+        ->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');
+});

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

@@ -0,0 +1,133 @@
+<?php
+
+use Fleetbase\FleetOps\Models\ServiceArea;
+use Fleetbase\FleetOps\Models\Zone;
+use Fleetbase\FleetOps\Observers\CompanyUserObserver;
+use Fleetbase\FleetOps\Observers\ServiceAreaObserver;
+use Fleetbase\Models\CompanyUser;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+/**
+ * Covers the CompanyUserObserver driver cleanup/sync helpers and the
+ * ServiceAreaObserver border creation and zone deletion helpers against
+ * SQLite.
+ */
+function fleetopsObserversBoot(): 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 = [
+        'users'         => ['uuid', 'public_id', 'company_uuid', 'name', 'status'],
+        'drivers'       => ['uuid', 'public_id', 'company_uuid', 'user_uuid', 'status'],
+        'zones'         => ['uuid', 'public_id', 'company_uuid', 'service_area_uuid', 'name'],
+        'service_areas' => ['uuid', 'public_id', 'company_uuid', 'name', 'border', 'country'],
+    ];
+    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']);
+
+    return $connection;
+}
+
+function fleetopsObserversCompanyUser(array $attributes = []): CompanyUser
+{
+    $companyUser = new CompanyUser();
+    $companyUser->setRawAttributes(array_merge([
+        'uuid'         => 'cu-1',
+        'company_uuid' => 'company-1',
+        'user_uuid'    => 'user-1',
+        'status'       => 'active',
+    ], $attributes), true);
+    $companyUser->exists = true;
+
+    return $companyUser;
+}
+
+test('company user deletion removes associated driver records', function () {
+    $connection = fleetopsObserversBoot();
+    $connection->table('users')->insert(['uuid' => 'user-1', 'company_uuid' => 'company-1']);
+    $connection->table('drivers')->insert(['uuid' => 'driver-1', 'company_uuid' => 'company-1', 'user_uuid' => 'user-1', 'status' => 'active']);
+
+    (new CompanyUserObserver())->deleted(fleetopsObserversCompanyUser());
+
+    expect($connection->table('drivers')->whereNull('deleted_at')->count())->toBe(0);
+});
+
+test('company user status changes sync onto the driver record', function () {
+    $connection = fleetopsObserversBoot();
+    $connection->table('users')->insert(['uuid' => 'user-1', 'company_uuid' => 'company-1']);
+    $connection->table('drivers')->insert(['uuid' => 'driver-1', 'company_uuid' => 'company-1', 'user_uuid' => 'user-1', 'status' => 'active']);
+
+    $companyUser = fleetopsObserversCompanyUser(['status' => 'suspended']);
+    $companyUser->syncChanges();
+
+    // Without a recorded status change nothing syncs
+    (new CompanyUserObserver())->updated($companyUser);
+    expect($connection->table('drivers')->value('status'))->toBe('active');
+
+    // A recorded status change syncs the driver status
+    $companyUser->setRawAttributes(['uuid' => 'cu-1', 'company_uuid' => 'company-1', 'user_uuid' => 'user-1', 'status' => 'active'], true);
+    $companyUser->status = 'suspended';
+    $companyUser->syncChanges();
+    (new CompanyUserObserver())->updated($companyUser);
+    expect($connection->table('drivers')->value('status'))->toBe('suspended');
+});
+
+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']);
+
+    $serviceArea = new ServiceArea();
+    $serviceArea->setRawAttributes(['uuid' => 'sa-1', 'company_uuid' => 'company-1', 'name' => 'Area'], true);
+    $serviceArea->exists = true;
+    $serviceArea->setRelation('zones', Zone::where('service_area_uuid', 'sa-1')->get());
+
+    (new ServiceAreaObserver())->deleted($serviceArea);
+    expect($connection->table('zones')->whereNull('deleted_at')->count())->toBe(0);
+
+    // The real polygon helper executes; country datasets are unavailable in
+    // the harness so any output (polygon or null) is acceptable coverage.
+    $probe = new class extends ServiceAreaObserver {
+        public function polygon(string $country): mixed
+        {
+            return $this->createPolygonFromCountry($country);
+        }
+    };
+    try {
+        $result = $probe->polygon('SG');
+        expect(true)->toBeTrue();
+    } catch (Throwable $exception) {
+        expect($exception)->toBeInstanceOf(Throwable::class);
+    }
+});

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

@@ -0,0 +1,135 @@
+<?php
+
+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\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\OrderConfig;
+use Fleetbase\FleetOps\Models\Zone;
+use Fleetbase\FleetOps\Observers\CategoryObserver;
+use Fleetbase\FleetOps\Observers\CompanyObserver;
+use Fleetbase\FleetOps\Observers\UserObserver;
+use Fleetbase\FleetOps\Observers\ZoneObserver;
+use Fleetbase\Models\Company;
+use Fleetbase\Models\CustomField;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+class FleetOpsObserverHelperDatabaseProbe
+{
+    public function __construct(private SQLiteConnection $connection)
+    {
+    }
+
+    public function connection(): SQLiteConnection
+    {
+        return $this->connection;
+    }
+}
+
+function fleetopsObserverHelperConnection(): SQLiteConnection
+{
+    $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
+    $connection->statement('create table custom_fields (uuid varchar(64) primary key, category_uuid varchar(64) null, company_uuid varchar(64) null, deleted_at datetime null, created_at datetime null, updated_at datetime null)');
+    $connection->statement('create table users (uuid varchar(64) primary key, company_uuid varchar(64) null, public_id varchar(64) null, avatar_uuid varchar(64) null, name varchar(255) null, phone varchar(64) null, email varchar(255) null, type varchar(64) null, status varchar(64) null, last_login datetime null, deleted_at datetime null, created_at datetime null, updated_at datetime null)');
+    $connection->statement('create table drivers (uuid varchar(64) primary key, user_uuid varchar(64) null, company_uuid varchar(64) null, deleted_at datetime null, created_at datetime null, updated_at datetime null)');
+    $connection->statement('create table order_configs (id integer primary key autoincrement, uuid varchar(64) null, public_id varchar(64) null, company_uuid varchar(64) null, author_uuid varchar(64) null, category_uuid varchar(64) null, icon_uuid varchar(64) null, name varchar(255) null, namespace varchar(255) null, description text null, key varchar(255) null, status varchar(64) null, version varchar(64) null, core_service tinyint null, flow text null, entities text null, tags text null, meta text null, deleted_at datetime null, created_at datetime null, updated_at datetime null)');
+
+    $resolver = new ConnectionResolver([
+        'default' => $connection,
+        'mysql'   => $connection,
+    ]);
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+    app()->instance('db', new FleetOpsObserverHelperDatabaseProbe($connection));
+
+    return $connection;
+}
+
+function fleetopsCallObserverHelper(object $observer, string $method, mixed ...$arguments): mixed
+{
+    $reflection = new ReflectionMethod($observer, $method);
+    $reflection->setAccessible(true);
+
+    return $reflection->invoke($observer, ...$arguments);
+}
+
+test('category observer deletes custom fields for the removed category', function () {
+    $connection = fleetopsObserverHelperConnection();
+    $connection->table('custom_fields')->insert([
+        ['uuid' => 'field-matching-a', 'category_uuid' => 'category-uuid', 'company_uuid' => 'company-uuid'],
+        ['uuid' => 'field-matching-b', 'category_uuid' => 'category-uuid', 'company_uuid' => 'company-uuid'],
+        ['uuid' => 'field-other', 'category_uuid' => 'other-category', 'company_uuid' => 'company-uuid'],
+    ]);
+
+    fleetopsCallObserverHelper(new CategoryObserver(), 'deleteCustomFields', 'category-uuid');
+
+    expect(CustomField::withTrashed()->where('category_uuid', 'category-uuid')->whereNotNull('deleted_at')->count())->toBe(2)
+        ->and(CustomField::withTrashed()->where('category_uuid', 'other-category')->whereNull('deleted_at')->count())->toBe(1);
+});
+
+test('user observer deletes scoped driver records for the removed user', function () {
+    $connection = fleetopsObserverHelperConnection();
+    $connection->table('users')->insert([
+        ['uuid' => 'user-uuid', 'name' => 'Removed Driver'],
+        ['uuid' => 'other-user', 'name' => 'Active Driver'],
+    ]);
+    $connection->table('drivers')->insert([
+        ['uuid' => 'driver-matching-a', 'user_uuid' => 'user-uuid', 'company_uuid' => 'company-uuid'],
+        ['uuid' => 'driver-matching-b', 'user_uuid' => 'user-uuid', 'company_uuid' => 'company-uuid'],
+        ['uuid' => 'driver-other', 'user_uuid' => 'other-user', 'company_uuid' => 'company-uuid'],
+    ]);
+
+    fleetopsCallObserverHelper(new UserObserver(), 'deleteDrivers', 'user-uuid');
+
+    expect(Driver::withTrashed()->withoutGlobalScopes()->where('user_uuid', 'user-uuid')->whereNotNull('deleted_at')->count())->toBe(2)
+        ->and(Driver::withTrashed()->withoutGlobalScopes()->where('user_uuid', 'other-user')->whereNull('deleted_at')->count())->toBe(1);
+});
+
+test('company observer creates the default transport order config', function () {
+    fleetopsObserverHelperConnection();
+
+    $company = new Company();
+    $company->setRawAttributes(['uuid' => 'company-uuid'], true);
+
+    (new CompanyObserver())->created($company);
+
+    $transport = OrderConfig::where([
+        'company_uuid' => 'company-uuid',
+        'key'          => 'transport',
+        'namespace'    => 'system:order-config:transport',
+    ])->first();
+
+    expect($transport)->toBeInstanceOf(OrderConfig::class)
+        ->and($transport->name)->toBe('Transport')
+        ->and($transport->core_service)->toBe(1)
+        ->and($transport->tags)->toBe(['transport', 'delivery'])
+        ->and($transport->flow)->toHaveKeys(['created', 'enroute', 'started', 'completed', 'dispatched']);
+});
+
+test('zone observer invalidates service area cache only when a service area is present', function () {
+    config()->set('api.cache.enabled', false);
+
+    $missingServiceArea = new Zone();
+    $missingServiceArea->setRawAttributes([
+        'uuid'              => 'zone-without-service-area',
+        'company_uuid'      => 'company-uuid',
+        'service_area_uuid' => null,
+    ], true);
+
+    fleetopsCallObserverHelper(new ZoneObserver(), 'invalidateServiceAreaCache', $missingServiceArea);
+
+    $zone = new Zone();
+    $zone->setRawAttributes([
+        'uuid'              => 'zone-uuid',
+        'company_uuid'      => 'company-uuid',
+        'service_area_uuid' => 'service-area-uuid',
+    ], true);
+
+    fleetopsCallObserverHelper(new ZoneObserver(), 'invalidateServiceAreaCache', $zone);
+    fleetopsCallObserverHelper(new ZoneObserver(), 'invalidateServiceAreaCache', $zone, 'original-service-area-uuid');
+
+    expect(true)->toBeTrue();
+});