@fleetbase/fleetops-engine 0.6.68 → 0.6.70

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

@@ -9,7 +9,7 @@ if (!Illuminate\Support\Str::hasMacro('humanize')) {
 }
 
 use Fleetbase\FleetOps\Exceptions\CustomerUserConflictException;
-use Fleetbase\FleetOps\Exceptions\UserAlreadyExistsException;
+use Fleetbase\FleetOps\Exceptions\ProfileIdentityConflictException;
 use Fleetbase\FleetOps\Models\Contact;
 use Fleetbase\Models\User;
 use Illuminate\Database\ConnectionResolver;
@@ -75,9 +75,38 @@ function fleetopsContactCustomerUserBoot(): SQLiteConnection
     });
     Illuminate\Support\Facades\DB::clearResolvedInstance('db');
 
+    app()->instance('hash', new class implements Illuminate\Contracts\Hashing\Hasher {
+        public function info($hashedValue): array
+        {
+            return [];
+        }
+
+        public function make($value, array $options = []): string
+        {
+            return md5((string) $value);
+        }
+
+        public function check($value, $hashedValue, array $options = []): bool
+        {
+            return md5((string) $value) === $hashedValue;
+        }
+
+        public function needsRehash($hashedValue, array $options = []): bool
+        {
+            return false;
+        }
+
+        public function verifyConfiguration($value): bool
+        {
+            return true;
+        }
+    });
+    Illuminate\Support\Facades\Hash::clearResolvedInstance('hash');
+
     $schema = $connection->getSchemaBuilder();
     $tables = [
         'contacts'              => ['uuid', 'public_id', 'company_uuid', 'user_uuid', 'name', 'email', 'phone', 'type', 'title'],
+        'drivers'               => ['uuid', 'public_id', 'company_uuid', 'user_uuid'],
         'users'                 => ['uuid', 'public_id', 'company_uuid', 'name', 'email', 'phone', 'username', 'password', 'timezone', 'status', 'type', 'slug', 'avatar_uuid', 'last_login'],
         'companies'             => ['uuid', 'public_id', 'name', 'timezone', 'owner_uuid'],
         'company_users'         => ['uuid', 'company_uuid', 'user_uuid', 'status'],
@@ -188,24 +217,45 @@ test('create user from contact adopts an existing matching user', function () {
         ->and($connection->table('users')->count())->toBe(1);
 });
 
-test('create user from contact rejects users already linked to another contact', function () {
+test('create user from contact rejects an account that already holds a contact in the company', function () {
     $connection = fleetopsContactCustomerUserBoot();
-    // The contact user() relation constrains users.type against the querying
-    // contact type, which is null in the static whereHas context — a null-typed
-    // user keeps the linked-contact subquery matchable.
-    $connection->table('users')->insert(['uuid' => 'user-9', 'company_uuid' => 'company-1', 'email' => 'taken@example.com', 'type' => null]);
+    $connection->table('users')->insert(['uuid' => 'user-9', 'company_uuid' => 'company-1', 'email' => 'taken@example.com', 'type' => 'contact']);
     $connection->table('contacts')->insert(['uuid' => 'contact-owner', 'company_uuid' => 'company-1', 'user_uuid' => 'user-9', 'name' => 'Owner', 'type' => 'contact']);
     $contact = fleetopsContactCustomerUserContact(['uuid' => 'contact-2', 'email' => 'taken@example.com']);
 
-    expect(fn () => Contact::createUserFromContact($contact))->toThrow(UserAlreadyExistsException::class);
+    expect(fn () => Contact::createUserFromContact($contact))
+        ->toThrow(ProfileIdentityConflictException::class, 'A contact with this email already exists.');
 });
 
-test('create user from contact rejects staff users for customer contacts', function () {
+test('create user from contact rejects staff users of another organization for customer contacts', function () {
     $connection = fleetopsContactCustomerUserBoot();
-    $connection->table('users')->insert(['uuid' => 'user-9', 'company_uuid' => 'company-1', 'email' => 'staff@example.com', 'type' => 'staff']);
+    $connection->table('users')->insert(['uuid' => 'user-9', 'company_uuid' => 'company-other', 'email' => 'staff@example.com', 'type' => 'user']);
     $contact = fleetopsContactCustomerUserContact(['type' => 'customer', 'email' => 'staff@example.com']);
 
-    expect(fn () => Contact::createUserFromContact($contact))->toThrow(CustomerUserConflictException::class);
+    expect(fn () => Contact::createUserFromContact($contact))
+        ->toThrow(ProfileIdentityConflictException::class, 'This email is already in use by another account.');
+});
+
+test('create user from contact links a staff member of the organization without changing their role', function () {
+    $connection = fleetopsContactCustomerUserBoot();
+    $connection->table('users')->insert(['uuid' => 'user-9', 'company_uuid' => 'company-1', 'email' => 'staff@example.com', 'type' => 'user']);
+    $contact = fleetopsContactCustomerUserContact(['type' => 'customer', 'email' => 'Staff@Example.com']);
+
+    $user = Contact::createUserFromContact($contact);
+
+    expect($user->uuid)->toBe('user-9')
+        ->and($user->type)->toBe('user')
+        ->and($contact->user_uuid)->toBe('user-9')
+        ->and($connection->table('model_has_roles')->count())->toBe(0);
+});
+
+test('create user from contact rejects a managed account of another type', function () {
+    $connection = fleetopsContactCustomerUserBoot();
+    $connection->table('users')->insert(['uuid' => 'user-9', 'company_uuid' => 'company-1', 'phone' => '+6591112222', 'type' => 'driver']);
+    $contact = fleetopsContactCustomerUserContact(['type' => 'customer', 'phone' => '+65 9111-2222']);
+
+    expect(fn () => Contact::createUserFromContact($contact))
+        ->toThrow(ProfileIdentityConflictException::class, 'This phone number is already used by a driver.');
 });
 
 test('create user from contact assigns the customer role and persists the link', function () {
@@ -305,17 +355,27 @@ test('identity lookup helpers resolve users by email phone and uuid', function (
 
 test('assert customer identity is available detects staff conflicts', function () {
     $connection = fleetopsContactCustomerUserBoot();
-    $connection->table('users')->insert(['uuid' => 'user-1', 'company_uuid' => 'company-1', 'email' => 'staff@example.com', 'type' => 'staff']);
+    $connection->table('users')->insert([
+        ['uuid' => 'user-1', 'company_uuid' => 'company-1', 'email' => 'staff@example.com', 'type' => 'staff'],
+        ['uuid' => 'user-2', 'company_uuid' => 'company-1', 'email' => 'driver@example.com', 'type' => 'driver'],
+    ]);
 
     $nonCustomer = fleetopsContactCustomerUserContact();
     $nonCustomer->assertCustomerIdentityIsAvailable();
 
-    $conflicted = fleetopsContactCustomerUserContact(['type' => 'customer', 'email' => 'staff@example.com']);
-    expect(fn () => $conflicted->assertCustomerIdentityIsAvailable())->toThrow(CustomerUserConflictException::class);
+    // A staff member of the organization can hold a customer profile
+    $staffMember = fleetopsContactCustomerUserContact(['type' => 'customer', 'email' => 'staff@example.com']);
+    $staffMember->assertCustomerIdentityIsAvailable();
+
+    // A driver's managed account cannot
+    $conflicted = fleetopsContactCustomerUserContact(['type' => 'customer', 'email' => 'driver@example.com']);
+    expect(fn () => $conflicted->assertCustomerIdentityIsAvailable())
+        ->toThrow(CustomerUserConflictException::class, 'This email is already used by a driver and cannot be used for a customer account.');
 
     // An already-assigned user is checked ahead of the identity lookup, so a
     // contact whose email matches nothing still trips on its own assignment
-    $connection->table('users')->insert(['uuid' => '33333333-3333-4333-8333-333333333333', 'company_uuid' => 'company-1', 'email' => 'assigned@example.com', 'type' => 'staff']);
+    // (a staff account of another organization)
+    $connection->table('users')->insert(['uuid' => '33333333-3333-4333-8333-333333333333', 'company_uuid' => 'company-other', 'email' => 'assigned@example.com', 'type' => 'staff']);
     $assigned = fleetopsContactCustomerUserContact([
         'type'      => 'customer',
         'email'     => 'unmatched@example.com',
@@ -368,3 +428,19 @@ test('normalize customer user creates company membership and assigns the custome
     expect($connection->table('company_users')->where('user_uuid', 'user-n1')->count())->toBe(1)
         ->and($connection->table('model_has_roles')->count())->toBeGreaterThanOrEqual(1);
 });
+
+test('normalize customer user keeps a staff member of the organization untouched', function () {
+    $connection = fleetopsContactCustomerUserBoot();
+    $connection->table('companies')->insert(['uuid' => 'company-1', 'name' => 'Acme']);
+    $connection->table('users')->insert(['uuid' => 'user-s1', 'company_uuid' => 'company-1', 'name' => 'Staff', 'email' => 'staff@example.com', 'type' => 'user', 'status' => 'active']);
+
+    $contact = fleetopsContactCustomerUserContact(['type' => 'customer', 'user_uuid' => 'user-s1']);
+    $user    = User::where('uuid', 'user-s1')->first();
+
+    expect($contact->normalizeCustomerUser($user))->toBe($user)
+        ->and($contact->getRelation('user'))->toBe($user)
+        // A team member's account keeps its own organization membership and role
+        ->and($connection->table('company_users')->count())->toBe(0)
+        ->and($connection->table('model_has_roles')->count())->toBe(0)
+        ->and($connection->table('users')->where('uuid', 'user-s1')->value('type'))->toBe('user');
+});

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

@@ -25,7 +25,8 @@ class FleetOpsContactUnitCompanyFake extends Company
     public array $addUserCalls                              = [];
     public ?FleetOpsContactUnitCompanyUserFake $companyUser = null;
 
-    public function addUser(User $user, string $role = 'Administrator', string $status = 'active'): CompanyUser
+    // Matches core-api 1.6.63+, where no role is granted unless one is given.
+    public function addUser(User $user, ?string $role = null, string $status = 'active'): CompanyUser
     {
         $this->addUserCalls[] = [$user, $role, $status];
 
@@ -71,9 +72,18 @@ class FleetOpsContactUnitUserFake extends User
         return true;
     }
 
+    public function save(array $options = []): bool
+    {
+        $this->updates[] = $this->getDirty();
+        $this->syncOriginal();
+
+        return true;
+    }
+
     public function delete()
     {
         $this->deleted = true;
+        $this->setAttribute('deleted_at', '2026-01-01 00:00:00');
 
         return true;
     }
@@ -180,6 +190,16 @@ class FleetOpsContactUnitAssignableFake extends FleetOpsContactUnitFake
     }
 }
 
+function fleetopsContactUnitUseProfileTables(): SQLiteConnection
+{
+    $connection = fleetopsContactUnitUseInMemoryConnection();
+    $connection->statement('create table drivers (uuid varchar(64), user_uuid varchar(64) null, company_uuid varchar(64) null, deleted_at datetime null)');
+    $connection->statement('create table contacts (uuid varchar(64), user_uuid varchar(64) null, company_uuid varchar(64) null, deleted_at datetime null)');
+    $connection->statement('create table company_users (uuid varchar(64), user_uuid varchar(64) null, company_uuid varchar(64) null, created_at datetime null, updated_at datetime null, deleted_at datetime null)');
+
+    return $connection;
+}
+
 function fleetopsContactUnitUseInMemoryConnection(): SQLiteConnection
 {
     $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
@@ -496,6 +516,8 @@ test('contact user conflict helpers guard staff users and allow customers', func
 });
 
 test('contact sync delete and user presence helpers use loaded user relations', function () {
+    fleetopsContactUnitUseProfileTables();
+
     $user = new FleetOpsContactUnitUserFake();
     $user->setRawAttributes([
         'uuid' => 'user-uuid',
@@ -521,6 +543,7 @@ test('contact sync delete and user presence helpers use loaded user relations',
     ]);
     $contact->setRelation('user', $user);
     $contact->fakeUser = $user;
+    $contact->exists   = true;
 
     expect($contact->syncWithUser())->toBeTrue()
         ->and($user->updates)->toBe([[
@@ -543,20 +566,40 @@ test('contact sync delete and user presence helpers use loaded user relations',
         ->and($unlinked->doesntHaveUser())->toBeTrue();
 });
 
-test('contact delete user ignores mismatched relation types', function () {
+test('contact delete user leaves team member accounts alone', function () {
     $user = new FleetOpsContactUnitUserFake();
     $user->setRawAttributes([
         'uuid' => 'user-uuid',
-        'type' => 'customer',
+        'type' => 'user',
     ], true);
 
-    $contact = new FleetOpsContactUnitFake(['type' => 'contact']);
-    $contact->setRelation('user', $user);
+    $contact           = new FleetOpsContactUnitFake(['type' => 'customer']);
+    $contact->fakeUser = $user;
 
     expect($contact->deleteUser())->toBeFalse()
         ->and($user->deleted)->toBeFalse();
 });
 
+test('contact delete user keeps a managed account still used by another organization', function () {
+    $connection = fleetopsContactUnitUseProfileTables();
+    $connection->table('drivers')->insert(['uuid' => 'driver-elsewhere', 'user_uuid' => 'user-uuid', 'company_uuid' => 'other-company']);
+    $connection->table('company_users')->insert([
+        ['uuid' => 'cu-1', 'user_uuid' => 'user-uuid', 'company_uuid' => 'company-uuid'],
+        ['uuid' => 'cu-2', 'user_uuid' => 'user-uuid', 'company_uuid' => 'other-company'],
+    ]);
+
+    $user = new FleetOpsContactUnitUserFake();
+    $user->setRawAttributes(['uuid' => 'user-uuid', 'type' => 'driver'], true);
+
+    $contact           = new FleetOpsContactUnitFake(['type' => 'contact', 'company_uuid' => 'company-uuid']);
+    $contact->fakeUser = $user;
+
+    // The account only leaves this organization
+    expect($contact->deleteUser())->toBeFalse()
+        ->and($user->deleted)->toBeFalse()
+        ->and($connection->table('company_users')->whereNull('deleted_at')->pluck('company_uuid')->all())->toBe(['other-company']);
+});
+
 test('contact real user helpers return loaded relations without database lookup', function () {
     $user = new FleetOpsContactUnitUserFake();
     $user->setRawAttributes([

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/Orchestration/VroomEngineTransportAndSettingsTest.php

@@ -251,3 +251,23 @@ test('connection settings fall back to defaults when the settings table is absen
     expect($call('resolveVroomBaseUri'))->toBeString()
         ->and($call('resolveVroomApiKey'))->toBeIn([null, '']);
 });
+
+test('allocation resolves organization settings from the orders company regardless of session', function (?string $sessionCompany) {
+    $connection = fleetopsVroomBoot();
+    $connection->table('settings')->insert([
+        ['key' => 'company.company-2.vroom', 'value' => json_encode(['api_host' => 'https://company-two-vroom.test'])],
+        ['key' => 'company.company-1.vroom', 'value' => json_encode(['api_host' => 'https://company-one-vroom.test'])],
+    ]);
+
+    $order = fleetopsVroomOrder('order_vroom_queued', fleetopsVroomPlace('p-9', new Point(1.31, 103.81)), null);
+    $order->setAttribute('company_uuid', 'company-2');
+    $vehicle = fleetopsVroomVehicle('vehicle_vroom_queued', new Point(1.20, 103.70));
+
+    Http::fake(['*' => Http::response(['routes' => [], 'unassigned' => [], 'summary' => []], 200)]);
+
+    // Background allocation must not depend on an absent or unrelated session.
+    session(['company' => $sessionCompany]);
+    (new VroomOrchestrationEngine())->allocate(collect([$order]), collect([$vehicle]));
+
+    Http::assertSent(fn ($request) => str_starts_with($request->url(), 'https://company-two-vroom.test'));
+})->with([null, 'company-1']);

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);
+});