@fleetbase/fleetops-engine 0.6.67 → 0.6.69

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

@@ -116,7 +116,7 @@ test('sensor model exposes relation builders and logging options', function () {
 
     $sensor = new Sensor();
 
-    expect($sensor->getSlugOptions()->generateSlugFrom)->toBe(['name', 'sensor_type'])
+    expect($sensor->getSlugOptions()->generateSlugFrom)->toBe(['name', 'type'])
         ->and($sensor->getSlugOptions()->slugField)->toBe('slug')
         ->and($sensor->getActivitylogOptions()->logOnlyDirty)->toBeTrue()
         ->and($sensor->telematic())->toBeInstanceOf(BelongsTo::class)
@@ -222,7 +222,7 @@ test('sensor scopes write expected query constraints', function () {
             ->and($sensor->scopeActive($query))->toBe($query)
             ->and($sensor->scopeWithRecentReadings($query, 30))->toBe($query)
             ->and($sensor->scopeOutOfThreshold($query))->toBe($query)
-            ->and($query->calls[0])->toBe(['where', ['sensor_type', 'temperature']])
+            ->and($query->calls[0])->toBe(['where', ['type', 'temperature']])
             ->and($query->calls[1])->toBe(['where', ['status', 'active']])
             ->and($query->calls[2][0])->toBe('where')
             ->and($query->calls[2][1][0])->toBe('last_reading_at')

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

@@ -176,45 +176,51 @@ test('customer creation forces the customer type and scopes orders', function ()
     expect($customer->orders())->toBeInstanceOf(HasMany::class);
 });
 
-test('contact observer availability checks and deletion resolve against users', function () {
+test('contact observer deletion releases the managed account and leaves team members alone', function () {
     $connection = fleetopsSmallModelBoot();
-    $connection->table('users')->insert(['uuid' => 'user-2', 'company_uuid' => 'company-1', 'email' => 'taken@example.test', 'phone' => '+6512345678']);
+    config(['activitylog.enabled' => false]);
+    app()->bind(Illuminate\Contracts\Config\Repository::class, fn () => config());
+    $connection->getSchemaBuilder()->create('drivers', function ($blueprint) {
+        $blueprint->increments('id');
+        $blueprint->string('uuid')->nullable();
+        $blueprint->string('company_uuid')->nullable();
+        $blueprint->string('user_uuid')->nullable();
+        $blueprint->timestamp('deleted_at')->nullable();
+    });
+    $connection->table('users')->insert([
+        ['uuid' => '11111111-1111-4111-8111-111111111111', 'company_uuid' => 'company-1', 'type' => 'contact'],
+        ['uuid' => '22222222-2222-4222-8222-222222222222', 'company_uuid' => 'company-1', 'type' => 'user'],
+    ]);
 
-    $observer   = new ContactObserver();
-    $reflection = new ReflectionClass($observer);
+    $observer = new ContactObserver();
 
     $contact = new Fleetbase\FleetOps\Models\Contact();
-    $contact->setRawAttributes(['uuid' => 'contact-1', 'company_uuid' => 'company-1', 'user_uuid' => 'user-1', 'email' => 'taken@example.test', 'phone' => '+6512345678', 'type' => 'contact'], true);
+    $contact->setRawAttributes(['uuid' => 'contact-1', 'company_uuid' => 'company-1', 'user_uuid' => '11111111-1111-4111-8111-111111111111', 'type' => 'contact'], true);
     $contact->exists = true;
 
-    $emailCheck = $reflection->getMethod('isEmailUnavailable');
-    $emailCheck->setAccessible(true);
-    expect($emailCheck->invoke($observer, $contact))->toBeTrue();
-
-    $phoneCheck = $reflection->getMethod('isPhoneUnavailable');
-    $phoneCheck->setAccessible(true);
-    expect($phoneCheck->invoke($observer, $contact))->toBeTrue();
+    $staffContact = new Fleetbase\FleetOps\Models\Contact();
+    $staffContact->setRawAttributes(['uuid' => 'contact-2', 'company_uuid' => 'company-1', 'user_uuid' => '22222222-2222-4222-8222-222222222222', 'type' => 'contact'], true);
+    $staffContact->exists = true;
 
-    $contact->email = 'free@example.test';
-    $contact->phone = '+6599999999';
-    expect($emailCheck->invoke($observer, $contact))->toBeFalse()
-        ->and($phoneCheck->invoke($observer, $contact))->toBeFalse();
-
-    // Deletion removes the associated user account
     $observer->deleted($contact);
-    expect(true)->toBeTrue();
+    $observer->deleted($staffContact);
+
+    // The managed account had no other profile, so it is deleted
+    expect($connection->table('users')->where('uuid', '11111111-1111-4111-8111-111111111111')->value('deleted_at'))->not->toBeNull()
+        ->and($connection->table('users')->where('uuid', '22222222-2222-4222-8222-222222222222')->value('deleted_at'))->toBeNull();
 });
 
 test('contact observer rejects saves whose email or phone belongs to another account', function () {
     $connection = fleetopsSmallModelBoot();
-    $connection->table('users')->insert(['uuid' => '22222222-2222-4222-8222-222222222222', 'company_uuid' => 'company-1', 'email' => 'taken@example.test', 'phone' => '+6512345678']);
+    $connection->table('users')->insert([
+        ['uuid' => '11111111-1111-4111-8111-111111111111', 'company_uuid' => 'company-1', 'type' => 'contact', 'email' => 'free@example.test', 'phone' => '+6599999999'],
+        ['uuid' => '22222222-2222-4222-8222-222222222222', 'company_uuid' => 'company-1', 'type' => 'user', 'email' => 'taken@example.test', 'phone' => '+6512345678'],
+    ]);
 
     $observer = new ContactObserver();
 
-    // The availability checks are private, so the guards can only be reached
-    // through saving() with a contact that genuinely collides on a real table.
     // hasUser() keys off a well-formed uuid, so a real one keeps saving() from
-    // detouring into account provisioning before it reaches the guards.
+    // detouring into account provisioning before it reaches the sync.
     $contact = new Fleetbase\FleetOps\Models\Contact();
     $contact->setRawAttributes([
         'uuid'         => 'contact-collide',
@@ -226,23 +232,16 @@ test('contact observer rejects saves whose email or phone belongs to another acc
     ], true);
     $contact->exists = true;
 
-    // wasChanged() reads the post-save change set, which setRawAttributes does
-    // not populate — syncChanges promotes the pending edit into it.
     $contact->email = 'taken@example.test';
-    $contact->syncChanges();
 
     expect(fn () => $observer->saving($contact))
-        ->toThrow(Exception::class, 'Email attempting to update for contact is not available.');
+        ->toThrow(Fleetbase\FleetOps\Exceptions\ProfileIdentityConflictException::class, 'This email is already in use by another account.');
 
-    // The phone guard sits behind the email one, so it only surfaces once the
-    // email is back to an available value
-    $contact->syncOriginal();
     $contact->email = 'free@example.test';
     $contact->phone = '+6512345678';
-    $contact->syncChanges();
 
     expect(fn () => $observer->saving($contact))
-        ->toThrow(Exception::class, 'Phone attempting to update for contact is not available.');
+        ->toThrow(Fleetbase\FleetOps\Exceptions\ProfileIdentityConflictException::class, 'This phone number is already in use by another account.');
 });
 
 test('tracking status request authorizes by session and rejects duplicates', function () {

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

@@ -98,11 +98,16 @@ test('driver observer seams unassign orders and resolve the driver user', functi
         ->and($connection->table('orders')->where('uuid', 'order-seam-1')->value('driver_assigned_uuid'))->toBeNull()
         ->and($connection->table('orders')->where('uuid', 'order-seam-2')->value('driver_assigned_uuid'))->toBe('driver-other');
 
-    // The linked account resolves only when it is still a plain user
+    // The linked account resolves whatever its type: releaseForProfile decides
+    // whether a managed account is deleted and leaves a team member alone
     expect(fleetopsObserverSeamInvoke(Fleetbase\FleetOps\Observers\DriverObserver::class, 'findDriverUser', [$driver])?->uuid)->toBe('user-seam-1');
 
+    $managedDriver = new Driver();
+    $managedDriver->setRawAttributes(['uuid' => 'driver-seam-2', 'user_uuid' => 'user-seam-2'], true);
+    expect(fleetopsObserverSeamInvoke(Fleetbase\FleetOps\Observers\DriverObserver::class, 'findDriverUser', [$managedDriver])?->uuid)->toBe('user-seam-2');
+
     $driverWithoutUser = new Driver();
-    $driverWithoutUser->setRawAttributes(['uuid' => 'driver-seam-2', 'user_uuid' => 'user-seam-2'], true);
+    $driverWithoutUser->setRawAttributes(['uuid' => 'driver-seam-3', 'user_uuid' => null], true);
     expect(fleetopsObserverSeamInvoke(Fleetbase\FleetOps\Observers\DriverObserver::class, 'findDriverUser', [$driverWithoutUser]))->toBeNull();
 });
 

package/server/tests/Unit/Providers/FleetOpsAiRegistrationTest.php

@@ -4,6 +4,10 @@ if (!class_exists('Fleetbase\Ai\Support\AiCapabilityRegistry', false)) {
     eval('namespace Fleetbase\Ai\Support; class AiCapabilityRegistry { public array $registered = []; public function register($capability) { $this->registered[] = $capability; return $this; } }');
 }
 
+if (!class_exists('Fleetbase\Ai\Support\Commands\AiCommandRegistry', false)) {
+    eval('namespace Fleetbase\Ai\Support\Commands; class AiCommandRegistry { public array $registered = []; public function registerMany(array $commands) { $this->registered = array_merge($this->registered, $commands); return $this; } }');
+}
+
 if (!class_exists('Fleetbase\Ai\Support\AiQueryRegistry', false)) {
     eval('namespace Fleetbase\Ai\Support; class AiQueryRegistry { public array $registered = []; public function register($resource = null) { $this->registered[] = $resource; return $this; } }');
 }
@@ -44,9 +48,18 @@ test('ai capability registration wires query resources and capabilities', functi
     $capabilityRegistry = app(Fleetbase\Ai\Support\AiCapabilityRegistry::class);
 
     fwrite(STDERR, "\nDBG ai: " . json_encode([is_object($queryRegistry) ? get_class($queryRegistry) : gettype($queryRegistry), is_object($capabilityRegistry) ? get_class($capabilityRegistry) : gettype($capabilityRegistry), is_object($capabilityRegistry) ? count($capabilityRegistry->registered) : null]) . "\n");
-    expect($capabilityRegistry->registered)->toHaveCount(9)
+    expect($capabilityRegistry->registered)->toHaveCount(13)
         ->and(collect($capabilityRegistry->registered)->map(fn ($capability) => get_class($capability)))
-        ->toContain(Fleetbase\FleetOps\Support\Ai\Capabilities\SearchResourcesCapability::class);
+        ->toContain(
+            Fleetbase\FleetOps\Support\Ai\Capabilities\SearchResourcesCapability::class,
+            Fleetbase\FleetOps\Support\Ai\Tools\SearchResourcesTool::class,
+            Fleetbase\FleetOps\Support\Ai\Tools\CreateOrderTool::class,
+            Fleetbase\FleetOps\Support\Ai\Tools\OptimizeOrderRouteTool::class,
+            Fleetbase\FleetOps\Support\Ai\Tools\ImportOrdersTool::class,
+        );
+
+    $commandRegistry = app(Fleetbase\Ai\Support\Commands\AiCommandRegistry::class);
+    expect(collect($commandRegistry->registered)->pluck('id'))->toContain('fleet-ops.orders.create', 'fleet-ops.settings.map.open');
 
     // The query resources helper registers the fleet-ops queryables directly
     $freshQueryRegistry = new Fleetbase\Ai\Support\AiQueryRegistry();

package/server/tests/Unit/Support/Ai/AssetStatusCapabilityQueriesTest.php

@@ -117,4 +117,46 @@ test('search capability queries scope companies with eager relations', function
         ->and($helper('vehicleSearchQuery')->count())->toBe(0)
         ->and($helper('driverSearchQuery')->count())->toBe(3)
         ->and($helper('genericSearchQuery', Fleetbase\FleetOps\Models\Contact::class)->count())->toBe(0);
+
+    foreach ([Fleetbase\FleetOps\Models\WorkOrder::class, Fleetbase\FleetOps\Models\Maintenance::class, Fleetbase\FleetOps\Models\Device::class, Fleetbase\FleetOps\Models\Sensor::class, Fleetbase\FleetOps\Models\Telematic::class] as $modelClass) {
+        expect($helper('genericSearchQuery', $modelClass))->toBeInstanceOf(Illuminate\Database\Eloquent\Builder::class);
+    }
+});
+
+test('asset status scoped queries resolve a list permission for every supported model', function () {
+    fleetopsAssetStatusCapabilityBoot();
+
+    $capability = (new ReflectionClass(AssetStatusCapability::class))->newInstanceWithoutConstructor();
+    $scoped     = new ReflectionMethod(AssetStatusCapability::class, 'scopedQuery');
+    $scoped->setAccessible(true);
+
+    foreach ([Fleetbase\FleetOps\Models\Vehicle::class, Fleetbase\FleetOps\Models\Device::class, Fleetbase\FleetOps\Models\Sensor::class, Fleetbase\FleetOps\Models\Telematic::class, Fleetbase\FleetOps\Models\Contact::class] as $modelClass) {
+        expect($scoped->invoke($capability, $modelClass))->toBeInstanceOf(Illuminate\Database\Eloquent\Builder::class);
+    }
+});
+
+test('capability queries apply IAM directives for the list permission when the directive macro is available', function () {
+    fleetopsAssetStatusCapabilityBoot();
+
+    if (!Illuminate\Database\Eloquent\Builder::hasGlobalMacro('applyDirectivesForPermissions')) {
+        Illuminate\Database\Eloquent\Builder::macro('applyDirectivesForPermissions', function (string|array $names = []) {
+            $GLOBALS['fleetopsAppliedDirectivePermissions'][] = $names;
+
+            return $this;
+        });
+    }
+
+    $GLOBALS['fleetopsAppliedDirectivePermissions'] = [];
+
+    $capability = (new ReflectionClass(AssetStatusCapability::class))->newInstanceWithoutConstructor();
+    $scope      = new ReflectionMethod(AssetStatusCapability::class, 'scopeToPermission');
+    $scope->setAccessible(true);
+    $plain = new stdClass();
+
+    expect($scope->invoke($capability, $plain, 'fleet-ops list driver'))->toBe($plain);
+
+    $builder = Fleetbase\FleetOps\Models\Driver::query();
+
+    expect($scope->invoke($capability, $builder, 'fleet-ops list driver'))->toBe($builder)
+        ->and($GLOBALS['fleetopsAppliedDirectivePermissions'])->toContain('fleet-ops list driver');
 });

package/server/tests/Unit/Support/Ai/Capabilities/OrderInsightsCapabilityTest.php

@@ -123,6 +123,11 @@ class FleetOpsOrderInsightsCapabilityFake extends OrderInsightsCapability
         return $this->allowed && $permission === 'fleet-ops see order';
     }
 
+    protected function currency(): string
+    {
+        return 'USD';
+    }
+
     protected function orderQuery(?string $companyUuid): mixed
     {
         $this->companies[] = $companyUuid;
@@ -183,6 +188,7 @@ test('order insights resolve returns bounded aggregate order metrics', function
         'authorized'       => true,
         'metric'           => 'orders',
         'amount_threshold' => 125.50,
+        'amount_currency'  => 'USD',
         'count'            => 7,
         'counts_by_status' => ['completed' => 5, 'active' => 2],
         'sample_order_ids' => ['order_1', 'order_2'],
@@ -196,7 +202,7 @@ test('order insights resolve returns bounded aggregate order metrics', function
         ->and($capability->companies)->toBe(['company-123'])
         ->and($capability->query->recordedCalls())->toContain(
             ['whereBetween', 'created_at', [$start, $end]],
-            ['whereHas', 'transaction', [['where', 'amount', '>', 125.50]]],
+            ['whereHas', 'transaction', [['where', 'amount', '>', 12550.0]]],
             ['count'],
             ['selectRaw', 'status, count(*) as aggregate'],
             ['groupBy', 'status'],
@@ -224,3 +230,15 @@ test('order insights resolve omits optional filters when prompt has no date or a
         ->and($capability->query->recordedCalls())->not->toContain(['whereBetween'])
         ->and($capability->query->recordedCalls())->not->toContain(['whereHas']);
 });
+
+test('order insights converts major-unit thresholds using the currency exponent', function () {
+    $capability = new FleetOpsOrderInsightsCapabilityFake();
+    $method     = new ReflectionMethod(OrderInsightsCapability::class, 'toMinorUnits');
+    $method->setAccessible(true);
+
+    expect($method->invoke($capability, 500.0, 'USD'))->toBe(50000)
+        ->and($method->invoke($capability, 125.5, 'usd'))->toBe(12550)
+        ->and($method->invoke($capability, 1000.0, 'JPY'))->toBe(1000)
+        ->and($method->invoke($capability, 1.5, 'BHD'))->toBe(1500)
+        ->and($method->invoke($capability, 10.0, 'NOT-A-CURRENCY'))->toBe(1000);
+});

package/server/tests/Unit/Support/Ai/Capabilities/SearchResourcesCapabilityTest.php

@@ -67,6 +67,17 @@ class FleetOpsSearchResourcesCapabilityProbe extends SearchResourcesCapability
     public array $queries            = [];
     public array $appliedLikes       = [];
 
+    public array $failing = [];
+
+    public function exposeSearchTerms(string $prompt): array
+    {
+        return $this->searchTerms($prompt);
+    }
+
+    protected function reportSearchFailure(string $resource, Throwable $e): void
+    {
+    }
+
     public function exposePromptMatches(string $prompt): bool
     {
         return $this->matchesPrompt($prompt);
@@ -103,6 +114,10 @@ class FleetOpsSearchResourcesCapabilityProbe extends SearchResourcesCapability
 
     protected function genericSearchQuery(string $modelClass)
     {
+        if ($modelClass === Sensor::class && in_array('sensors', $this->failing, true)) {
+            throw new RuntimeException("SQLSTATE[42S22]: Column not found: 1054 Unknown column 'sensor_type'");
+        }
+
         return match ($modelClass) {
             WorkOrder::class   => $this->queries['work_orders'],
             Maintenance::class => $this->queries['maintenances'],
@@ -197,7 +212,7 @@ test('search resources resolve returns authorized resource summaries across all
     $result = $capability->resolve(new AiTask(['prompt' => 'Find order ORDER-1 vehicle VEH-1 driver DRV-1 device DEV-1 sensor SNS-1 telematic TEL-1']));
 
     expect($capability->exposePromptMatches('look up work order WO-1'))->toBeTrue()
-        ->and($result['query_terms'])->toBe(['ORDER-1', 'VEH-1', 'DRV-1', 'device', 'DEV-1', 'sensor'])
+        ->and($result['query_terms'])->toBe(['ORDER-1', 'VEH-1', 'DRV-1', 'DEV-1', 'SNS-1', 'TEL-1'])
         ->and($result['results'])->toHaveKeys(['orders', 'vehicles', 'drivers', 'work_orders', 'maintenances', 'devices', 'sensors', 'telematics'])
         ->and($result['results']['orders'][0])->toMatchArray([
             'id'                   => 'order_public',
@@ -235,3 +250,72 @@ test('search resources resolve returns authorized resource summaries across all
         ->and($capability->queries['orders']->calls)->toContain(['limit', 5], ['get'])
         ->and($capability->appliedLikes)->not->toBeEmpty();
 });
+
+function fleetopsSearchResourcesEmptyQueries(): array
+{
+    return collect(['orders', 'vehicles', 'drivers', 'work_orders', 'maintenances', 'devices', 'sensors', 'telematics'])
+        ->mapWithKeys(fn ($key) => [$key => new FleetOpsSearchResourcesQueryFake()])
+        ->all();
+}
+
+test('search terms ignore ordinary words from real production prompts', function () {
+    $capability = new FleetOpsSearchResourcesCapabilityProbe();
+
+    expect($capability->exposeSearchTerms('i want turn this into a platform where i add cisterns and on a different page BUSINESS leave they orders'))->toBe([])
+        ->and($capability->exposeSearchTerms('Create a few dummy orders so we can test with it'))->toBe([])
+        ->and($capability->exposeSearchTerms('download order import template'))->toBe([])
+        ->and($capability->exposeSearchTerms('config driver app ยังไง'))->toBe([])
+        ->and($capability->exposeSearchTerms('como activar un conductor'))->toBe([]);
+});
+
+test('search terms keep record references such as public ids, plates, emails, quoted and capitalized names', function () {
+    $capability = new FleetOpsSearchResourcesCapabilityProbe();
+
+    expect($capability->exposeSearchTerms('status of order order_yhkejdnzgz'))->toBe(['order_yhkejdnzgz'])
+        ->and($capability->exposeSearchTerms('vehicle plate SBA1234Z'))->toBe(['SBA1234Z'])
+        ->and($capability->exposeSearchTerms('driver with email ada@example.com'))->toBe(['ada@example.com'])
+        ->and($capability->exposeSearchTerms('where is driver Jane Doe right now'))->toBe(['Jane', 'Doe'])
+        ->and($capability->exposeSearchTerms('find "north depot" vehicles'))->toBe(['north depot']);
+});
+
+test('search resources skips querying when the prompt has no record reference', function () {
+    $capability                     = new FleetOpsSearchResourcesCapabilityProbe();
+    $capability->allowedPermissions = $capability->permissions();
+    $capability->queries            = fleetopsSearchResourcesEmptyQueries();
+
+    $result = $capability->resolve(new AiTask(['prompt' => 'how do I create a new order']));
+
+    expect($result['query_terms'])->toBe([])
+        ->and($result['results'])->toBe([])
+        ->and($capability->appliedLikes)->toBe([]);
+});
+
+test('search resources never searches the dropped sensor_type column or status/uuid columns', function () {
+    $capability                     = new FleetOpsSearchResourcesCapabilityProbe();
+    $capability->allowedPermissions = $capability->permissions();
+    $capability->queries            = fleetopsSearchResourcesEmptyQueries();
+
+    $capability->resolve(new AiTask(['prompt' => 'find SNS-1']));
+
+    $columns = collect($capability->appliedLikes)->flatMap(fn ($like) => $like[0])->unique()->all();
+
+    expect($columns)->not->toContain('sensor_type')
+        ->and($columns)->not->toContain('status')
+        ->and($columns)->not->toContain('uuid')
+        ->and($columns)->not->toContain('type');
+});
+
+test('a failing resource search does not discard the other results or leak the error', function () {
+    $vehicle = fleetopsSearchResourcesModel(Vehicle::class, ['public_id' => 'vehicle_public', 'uuid' => 'vehicle-uuid', 'name' => 'Van 12']);
+
+    $capability                     = new FleetOpsSearchResourcesCapabilityProbe();
+    $capability->allowedPermissions = $capability->permissions();
+    $capability->failing            = ['sensors'];
+    $capability->queries            = array_merge(fleetopsSearchResourcesEmptyQueries(), ['vehicles' => new FleetOpsSearchResourcesQueryFake([$vehicle])]);
+
+    $result = $capability->resolve(new AiTask(['prompt' => 'find VEH-12']));
+
+    expect($result['results'])->toHaveKey('vehicles')
+        ->and($result['unavailable_search'])->toBe(['sensors'])
+        ->and(json_encode($result))->not->toContain('SQLSTATE');
+});

package/server/tests/Unit/Support/Ai/FleetOpsAiConsoleCommandsTest.php

@@ -0,0 +1,31 @@
+<?php
+
+use Fleetbase\FleetOps\Support\Ai\FleetOpsAiConsoleCommands;
+
+test('fleet-ops console commands are unique, complete, and only navigate or call allowlisted services', function () {
+    $commands = collect(FleetOpsAiConsoleCommands::all());
+
+    expect($commands->pluck('id')->duplicates())->toBeEmpty()
+        ->and($commands->every(fn ($command) => filled($command['label']) && filled($command['breadcrumb']) && filled($command['description']) && !empty($command['steps'])))->toBeTrue()
+        ->and($commands->every(fn ($command) => collect($command['steps'])->every(fn ($step) => $step['type'] === 'navigate'
+            ? str_starts_with($step['route'], 'console.fleet-ops.')
+            : $step['type'] === 'service' && $step['engine'] === FleetOpsAiConsoleCommands::ENGINE && preg_match('/^[a-zA-Z]+$/', $step['method']))))->toBeTrue()
+        ->and($commands->every(fn ($command) => ($command['audience'] ?? 'end_user') === 'end_user'))->toBeTrue();
+});
+
+test('fleet-ops console commands cover create, import, view, and settings', function () {
+    $commands = collect(FleetOpsAiConsoleCommands::all())->keyBy('id');
+
+    expect($commands['fleet-ops.orders.create']['steps'])->toBe([['type' => 'navigate', 'route' => 'console.fleet-ops.operations.orders.index.new']])
+        ->and($commands['fleet-ops.orders.create']['permissions'])->toBe(['fleet-ops create order'])
+        ->and($commands['fleet-ops.orders.import']['steps'][1])->toBe(['type' => 'service', 'engine' => '@fleetbase/fleetops-engine', 'service' => 'order-actions', 'method' => 'importOrders'])
+        ->and($commands['fleet-ops.customers.import']['steps'][1]['service'])->toBe('customer-actions')
+        ->and($commands['fleet-ops.customers.import']['permissions'])->toBe(['fleet-ops import contact'])
+        ->and($commands)->not->toHaveKey('fleet-ops.fleets.import')
+        ->and($commands['fleet-ops.drivers.view']['steps'][0]['models'])->toBe(['public_id'])
+        ->and($commands['fleet-ops.drivers.view']['params'])->toHaveKey('public_id')
+        ->and($commands['fleet-ops.settings.map.open']['steps'][0]['route'])->toBe('console.fleet-ops.settings.map')
+        ->and($commands['fleet-ops.settings.map.open']['permissions'])->toBe(['fleet-ops view map-settings'])
+        ->and($commands['fleet-ops.settings.map.open']['keywords'])->toContain('google maps', 'view maps')
+        ->and($commands['fleet-ops.settings.scheduling.open']['permissions'])->toBe([]);
+});