@fleetbase/fleetops-engine 0.6.57 → 0.6.59

package/server/tests/Unit/Console/Commands/SimulateGeofenceEventsCommandTest.php

@@ -0,0 +1,207 @@
+<?php
+
+use Carbon\Carbon;
+use Fleetbase\FleetOps\Console\Commands\SimulateGeofenceEvents;
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\ServiceArea;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Models\Zone;
+use Illuminate\Console\Command;
+
+class FleetOpsSimulateGeofenceEventsCommandProbe extends SimulateGeofenceEvents
+{
+    public array $arguments = [];
+    public array $options   = [];
+    public array $messages  = [];
+    public array $subjects  = [];
+    public array $geofences = [];
+    public array $reset     = [];
+    public array $inside    = [];
+    public array $outside   = [];
+    public array $ensured   = [];
+    public array $dwells    = [];
+
+    public function argument($key = null)
+    {
+        return $key === null ? $this->arguments : ($this->arguments[$key] ?? null);
+    }
+
+    public function option($key = null)
+    {
+        return $key === null ? $this->options : ($this->options[$key] ?? null);
+    }
+
+    public function info($string, $verbosity = null): void
+    {
+        $this->messages[] = ['info', $string];
+    }
+
+    public function error($string, $verbosity = null): void
+    {
+        $this->messages[] = ['error', $string];
+    }
+
+    public function line($string, $style = null, $verbosity = null): void
+    {
+        $this->messages[] = ['line', $string];
+    }
+
+    public function newLine($count = 1): void
+    {
+        $this->messages[] = ['newLine', $count];
+    }
+
+    protected function resolveSubject(string $identifier): array
+    {
+        return $this->subjects[$identifier] ?? [null, null];
+    }
+
+    protected function resolveGeofence(string $identifier): array
+    {
+        return $this->geofences[$identifier] ?? [null, null];
+    }
+
+    protected function resetState(string $subjectType, Driver|Vehicle $subject, Zone|ServiceArea $geofence): void
+    {
+        $this->reset[] = [$subjectType, $subject->uuid, $geofence->uuid];
+    }
+
+    protected function markInside(string $subjectType, Driver|Vehicle $subject, Zone|ServiceArea $geofence, Carbon $enteredAt): void
+    {
+        $this->inside[] = [$subjectType, $subject->uuid, $geofence->uuid, $enteredAt->toDateTimeString()];
+    }
+
+    protected function ensureEnteredAt(string $subjectType, Driver|Vehicle $subject, Zone|ServiceArea $geofence, Carbon $enteredAt): void
+    {
+        $this->ensured[] = [$subjectType, $subject->uuid, $geofence->uuid, $enteredAt->toDateTimeString()];
+    }
+
+    protected function markOutside(string $subjectType, Driver|Vehicle $subject, Zone|ServiceArea $geofence): void
+    {
+        $this->outside[] = [$subjectType, $subject->uuid, $geofence->uuid];
+    }
+
+    protected function calculateDwellMinutes(string $subjectType, Driver|Vehicle $subject, Zone|ServiceArea $geofence, int $fallback): int
+    {
+        $this->dwells[] = [$subjectType, $subject->uuid, $geofence->uuid, $fallback];
+
+        return 42;
+    }
+}
+
+class FleetOpsSimulateGeofenceZoneFake extends Zone
+{
+    public function getLatitudeAttribute(): float
+    {
+        return 1.3521;
+    }
+
+    public function getLongitudeAttribute(): float
+    {
+        return 103.8198;
+    }
+}
+
+function fleetopsSimulateGeofenceCommand(array $overrides = []): FleetOpsSimulateGeofenceEventsCommandProbe
+{
+    $command            = new FleetOpsSimulateGeofenceEventsCommandProbe();
+    $command->arguments = array_merge([
+        'subject'  => 'driver_public',
+        'geofence' => 'zone_public',
+        'events'   => 'sequence',
+    ], $overrides['arguments'] ?? []);
+    $command->options = array_merge([
+        'repeat'        => 1,
+        'sleep'         => 0,
+        'dwell-minutes' => 10,
+        'reset-state'   => false,
+        'no-log'        => true,
+    ], $overrides['options'] ?? []);
+
+    return $command;
+}
+
+function fleetopsSimulateGeofenceDriver(): Driver
+{
+    $driver = new Driver();
+    $driver->setRawAttributes([
+        'uuid'         => 'driver-uuid',
+        'public_id'    => 'driver_public',
+        'company_uuid' => 'company-uuid',
+    ], true);
+
+    return $driver;
+}
+
+function fleetopsSimulateGeofenceZone(): Zone
+{
+    $zone = new FleetOpsSimulateGeofenceZoneFake();
+    $zone->setRawAttributes([
+        'uuid'      => 'zone-uuid',
+        'public_id' => 'zone_public',
+    ], true);
+
+    return $zone;
+}
+
+test('simulate geofence command handle rejects invalid events and missing resources', function () {
+    $invalid = fleetopsSimulateGeofenceCommand([
+        'arguments' => ['events' => 'arrived'],
+    ]);
+
+    $missingSubject                           = fleetopsSimulateGeofenceCommand();
+    $missingSubject->geofences['zone_public'] = ['zone', fleetopsSimulateGeofenceZone()];
+
+    $missingGeofence                            = fleetopsSimulateGeofenceCommand();
+    $missingGeofence->subjects['driver_public'] = ['driver', fleetopsSimulateGeofenceDriver()];
+
+    expect($invalid->handle())->toBe(Command::FAILURE)
+        ->and($invalid->messages)->toContain(['error', 'Invalid arguments. Events must be entered|exited|dwelled|sequence or a comma-separated combination.'])
+        ->and($missingSubject->handle())->toBe(Command::FAILURE)
+        ->and($missingSubject->messages[0][1])->toContain('Unable to resolve subject [driver_public]')
+        ->and($missingGeofence->handle())->toBe(Command::FAILURE)
+        ->and($missingGeofence->messages[0][1])->toContain('Unable to resolve geofence [zone_public]');
+});
+
+test('simulate geofence command handle runs repeated no-log event sequence and state transitions', function () {
+    Carbon::setTestNow('2026-07-27 12:00:00');
+
+    $command = fleetopsSimulateGeofenceCommand([
+        'options' => [
+            'repeat'        => 2,
+            'dwell-minutes' => 15,
+            'reset-state'   => true,
+        ],
+    ]);
+    $command->subjects['driver_public']  = ['driver', fleetopsSimulateGeofenceDriver()];
+    $command->geofences['zone_public']   = ['zone', fleetopsSimulateGeofenceZone()];
+
+    expect($command->handle())->toBe(Command::SUCCESS)
+        ->and(session('company'))->toBe('company-uuid')
+        ->and($command->reset)->toBe([['driver', 'driver-uuid', 'zone-uuid']])
+        ->and($command->inside)->toHaveCount(4)
+        ->and($command->inside[0])->toBe(['driver', 'driver-uuid', 'zone-uuid', '2026-07-27 12:00:00'])
+        ->and($command->inside[1])->toBe(['driver', 'driver-uuid', 'zone-uuid', '2026-07-27 11:45:00'])
+        ->and($command->ensured)->toBe([
+            ['driver', 'driver-uuid', 'zone-uuid', '2026-07-27 11:45:00'],
+            ['driver', 'driver-uuid', 'zone-uuid', '2026-07-27 11:45:00'],
+        ])
+        ->and($command->dwells)->toBe([
+            ['driver', 'driver-uuid', 'zone-uuid', 15],
+            ['driver', 'driver-uuid', 'zone-uuid', 15],
+        ])
+        ->and($command->outside)->toBe([
+            ['driver', 'driver-uuid', 'zone-uuid'],
+            ['driver', 'driver-uuid', 'zone-uuid'],
+        ])
+        ->and($command->messages)->toContain(
+            ['line', 'Run 1/2'],
+            ['line', 'Run 2/2'],
+            ['info', '  -> dispatched geofence.entered'],
+            ['info', '  -> dispatched geofence.dwelled (15 min)'],
+            ['info', '  -> dispatched geofence.exited (42 min)'],
+            ['info', 'Geofence simulation complete.'],
+        );
+
+    Carbon::setTestNow();
+});

package/server/tests/Unit/Console/FixCommandsAndMaintenanceControllerTest.php

@@ -0,0 +1,256 @@
+<?php
+
+use Fleetbase\FleetOps\Console\Commands\FixCustomerCompanies;
+use Fleetbase\FleetOps\Console\Commands\FixInvalidPolymorphicRelationTypeNamespaces;
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\MaintenanceController;
+use Fleetbase\FleetOps\Models\Maintenance;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Http\Request;
+
+/**
+ * Covers the FixCustomerCompanies command helpers, the polymorphic
+ * namespace fixer traversal, and the internal MaintenanceController
+ * export/import/cost helpers against SQLite with an excel fake.
+ */
+if (!class_exists('Fleetbase\Http\Requests\ExportRequest', false)) {
+    eval('namespace Fleetbase\Http\Requests; class ExportRequest extends \Illuminate\Http\Request {}');
+}
+
+if (!class_exists('Fleetbase\Http\Requests\ImportRequest', false)) {
+    eval('namespace Fleetbase\Http\Requests; class ImportRequest extends \Illuminate\Http\Request {}');
+}
+
+if (!Request::hasMacro('resolveFilesFromIds')) {
+    Request::macro('resolveFilesFromIds', fn () => FleetOpsFixCommandsState::$files);
+}
+
+if (!function_exists('Fleetbase\Support\session')) {
+    eval('namespace Fleetbase\Support; function session($key = null, $default = null) { if ($key === null) { return new class { public function has($k) { return \session($k) !== null; } public function get($k, $d = null) { return \session($k, $d); } }; } return \session($key, $default); }');
+}
+
+if (!function_exists('Fleetbase\Support\auth')) {
+    eval('namespace Fleetbase\Support; function auth() { return new class { public function user() { return null; } public function id() { return null; } }; }');
+}
+
+class FleetOpsFixCommandsState
+{
+    public static array $files = [];
+}
+
+class FleetOpsFixCommandsExcelFake
+{
+    public array $downloads = [];
+    public array $imports   = [];
+
+    public function download($export, string $fileName): string
+    {
+        $this->downloads[] = [$export, $fileName];
+
+        return 'downloaded:' . $fileName;
+    }
+
+    public function import($import, $path, $disk = null): bool
+    {
+        $this->imports[] = [$import, $path, $disk];
+
+        if (str_contains((string) $path, 'unreadable')) {
+            throw new RuntimeException('Unable to read the spreadsheet.');
+        }
+
+        $import->imported++;
+
+        return true;
+    }
+}
+
+class FleetOpsFixCustomerCompaniesProbe extends FixCustomerCompanies
+{
+    public array $messages = [];
+
+    public function info($string, $verbosity = null)
+    {
+        $this->messages[] = ['info', $string];
+    }
+
+    public function error($string, $verbosity = null)
+    {
+        $this->messages[] = ['error', $string];
+    }
+
+    public function line($string, $style = null, $verbosity = null)
+    {
+        $this->messages[] = ['line', $string];
+    }
+
+    public function callHelper(string $method, ...$arguments): mixed
+    {
+        return $this->{$method}(...$arguments);
+    }
+}
+
+class FleetOpsPolymorphicFixerProbe extends FixInvalidPolymorphicRelationTypeNamespaces
+{
+    public array $fixed = [];
+
+    public function info($string, $verbosity = null)
+    {
+    }
+
+    public function line($string, $style = null, $verbosity = null)
+    {
+    }
+
+    protected function fixModelRelations(string $model, array $columns): void
+    {
+        $this->fixed[] = [$model, $columns];
+    }
+}
+
+class FleetOpsMaintenanceControllerProbe extends MaintenanceController
+{
+    public function callHelper(string $method, ...$arguments): mixed
+    {
+        return $this->{$method}(...$arguments);
+    }
+}
+
+function fleetopsFixCommandsBoot(): 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');
+
+    $excelFake = new FleetOpsFixCommandsExcelFake();
+    app()->instance('excel', $excelFake);
+    Maatwebsite\Excel\Facades\Excel::clearResolvedInstance('excel');
+    $GLOBALS['fleetopsFixCommandsExcelFake'] = $excelFake;
+
+    $schema = $connection->getSchemaBuilder();
+    $tables = [
+        'contacts'      => ['uuid', 'public_id', 'company_uuid', 'user_uuid', 'name', 'email', 'phone', 'type', 'meta'],
+        'users'         => ['uuid', 'public_id', 'company_uuid', 'name', 'email', 'phone', 'status', 'type'],
+        'companies'     => ['uuid', 'public_id', 'name'],
+        'company_users' => ['uuid', 'company_uuid', 'user_uuid', 'status'],
+        'maintenances'  => ['uuid', 'public_id', 'company_uuid', 'maintainable_type', 'maintainable_uuid', 'maintainable_id', 'type', 'status', 'line_items', 'labor_cost', 'tax', 'parts_cost', 'total_cost', 'meta'],
+    ];
+    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;
+}
+
+test('fix customer companies helpers resolve users companies and memberships', function () {
+    $connection = fleetopsFixCommandsBoot();
+    $connection->table('companies')->insert(['uuid' => 'company-1', 'name' => 'Acme']);
+    $connection->table('users')->insert(['uuid' => 'user-1', 'company_uuid' => 'company-1', 'email' => 'known@example.test']);
+    $connection->table('contacts')->insert(['uuid' => 'contact-1', 'company_uuid' => 'company-1', 'name' => 'Customer', 'email' => 'known@example.test', 'type' => 'customer']);
+
+    $probe = new FleetOpsFixCustomerCompaniesProbe();
+
+    expect($probe->callHelper('customers'))->toHaveCount(1)
+        ->and($probe->callHelper('userByEmail', 'known@example.test')?->uuid)->toBe('user-1')
+        ->and($probe->callHelper('userByEmail', 'unknown@example.test'))->toBeNull()
+        ->and($probe->callHelper('companyByUuid', 'company-1')?->name)->toBe('Acme')
+        ->and($probe->callHelper('missingCompanyUser', 'user-1', 'company-1'))->toBeTrue();
+
+    $connection->table('company_users')->insert(['uuid' => 'cu-1', 'company_uuid' => 'company-1', 'user_uuid' => 'user-1']);
+    expect($probe->callHelper('missingCompanyUser', 'user-1', 'company-1'))->toBeFalse();
+
+    // Assigning an existing user links and persists the relation
+    $customer = Fleetbase\FleetOps\Models\Contact::withoutGlobalScopes()->where('uuid', 'contact-1')->first();
+    $user     = Fleetbase\Models\User::where('uuid', 'user-1')->first();
+    $probe->callHelper('assignExistingUserToCustomer', $customer, $user);
+    expect($connection->table('contacts')->value('user_uuid'))->toBe('user-1')
+        ->and($probe->callHelper('customerUser', $customer))->not->toBeNull();
+});
+
+test('polymorphic namespace fixer traverses every configured model', function () {
+    fleetopsFixCommandsBoot();
+
+    $probe = new FleetOpsPolymorphicFixerProbe();
+    $probe->handle();
+
+    expect($probe->fixed)->toHaveCount(5)
+        ->and(collect($probe->fixed)->pluck(0)->all())->toContain(Fleetbase\FleetOps\Models\Order::class, Fleetbase\FleetOps\Models\Device::class);
+});
+
+test('maintenance export import and cost recalculation execute', function () {
+    $connection = fleetopsFixCommandsBoot();
+    $controller = new MaintenanceController();
+
+    $request  = Fleetbase\Http\Requests\ExportRequest::create('/int/v1/maintenances/export', 'POST', ['format' => 'csv', 'selections' => []]);
+    $response = $controller->export($request);
+    expect($response)->toStartWith('downloaded:maintenances-');
+
+    FleetOpsFixCommandsState::$files = [(object) ['path' => 'uploads/maintenances.xlsx']];
+    $imported                        = $controller->import(Fleetbase\Http\Requests\ImportRequest::create('/int/v1/maintenances/import', 'POST', ['disk' => 'local']));
+    expect($imported->getData(true)['imported'])->toBe(1);
+
+    // Cost recalculation derives parts and total costs from line items
+    $connection->table('maintenances')->insert([
+        'uuid'         => 'mnt-1',
+        'public_id'    => 'maintenance_costs',
+        'company_uuid' => 'company-1',
+        'line_items'   => json_encode([
+            ['quantity' => 2, 'unit_cost' => 500],
+            ['quantity' => 1, 'unit_cost' => 250],
+        ]),
+        'labor_cost'   => '1000',
+        'tax'          => '100',
+    ]);
+
+    $probe       = new FleetOpsMaintenanceControllerProbe();
+    $maintenance = $probe->callHelper('findMaintenanceForLineItem', 'maintenance_costs');
+    expect($maintenance)->toBeInstanceOf(Maintenance::class);
+
+    $probe->callHelper('recalculateCosts', $maintenance);
+    expect((int) $connection->table('maintenances')->value('parts_cost'))->toBe(1250)
+        ->and((int) $connection->table('maintenances')->value('total_cost'))->toBe(2350);
+});
+
+test('maintenance import reports an unreadable file instead of surfacing the reader error', function () {
+    fleetopsFixCommandsBoot();
+    $controller = new MaintenanceController();
+
+    FleetOpsFixCommandsState::$files = [
+        (object) ['path' => 'uploads/maintenances.xlsx'],
+        (object) ['path' => 'uploads/unreadable.xlsx'],
+    ];
+
+    $response = $controller->import(Fleetbase\Http\Requests\ImportRequest::create('/int/v1/maintenances/import', 'POST', ['disk' => 'local']));
+
+    // The reader throws on the second file, so the whole import fails rather than
+    // reporting a partial count for the first
+    expect($response->getData(true)['errors'] ?? [$response->getData(true)['error'] ?? null])
+        ->toContain('Invalid file, unable to process.')
+        ->and($GLOBALS['fleetopsFixCommandsExcelFake']->imports)->toHaveCount(2);
+});

package/server/tests/Unit/Console/FleetOpsCommandsTest.php

@@ -0,0 +1,198 @@
+<?php
+
+use Fleetbase\FleetOps\Console\Commands\DispatchOrders;
+use Fleetbase\FleetOps\Console\Commands\PurgeUnpurchasedServiceQuotes;
+use Illuminate\Console\Command;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+/**
+ * Covers the fleetops console commands against an in-memory SQLite fixture:
+ * purging unpurchased service quotes (deletions, empty runs, and the failure
+ * rollback branch) and dispatching scheduled orders (ready and not-ready
+ * branches).
+ */
+if (!function_exists('Fleetbase\FleetOps\Models\dispatch')) {
+    eval('namespace Fleetbase\FleetOps\Models; function dispatch($job = null) { \FleetOpsCommandsTestRecorder::$dispatched[] = $job; return new \Fleetbase\TestSupport\PendingDispatch(); }');
+}
+
+if (!function_exists('Fleetbase\FleetOps\Models\event')) {
+    eval('namespace Fleetbase\FleetOps\Models; function event($event = null) { \FleetOpsCommandsTestRecorder::$events[] = $event; return $event; }');
+}
+
+class FleetOpsCommandsTestRecorder
+{
+    public static array $dispatched = [];
+    public static array $events     = [];
+}
+
+class FleetOpsPurgeQuotesCommandProbe extends PurgeUnpurchasedServiceQuotes
+{
+    public array $messages   = [];
+    public bool $purgeThrows = false;
+
+    public function info($string, $verbosity = null)
+    {
+        $this->messages[] = ['info', $string];
+    }
+
+    public function error($string, $verbosity = null)
+    {
+        $this->messages[] = ['error', $string];
+    }
+
+    protected function purgeServiceQuotes($thresholdDate): int
+    {
+        if ($this->purgeThrows) {
+            throw new Exception('purge failed');
+        }
+
+        return parent::purgeServiceQuotes($thresholdDate);
+    }
+}
+
+class FleetOpsDispatchOrdersCommandProbe extends DispatchOrders
+{
+    public array $messages = [];
+    public array $options  = ['sandbox' => 'false'];
+
+    public function info($string, $verbosity = null)
+    {
+        $this->messages[] = ['info', $string];
+    }
+
+    public function alert($string, $verbosity = null)
+    {
+        $this->messages[] = ['alert', $string];
+    }
+
+    public function warn($string, $verbosity = null)
+    {
+        $this->messages[] = ['warn', $string];
+    }
+
+    public function option($key = null, $default = null)
+    {
+        return $this->options[$key] ?? $default;
+    }
+}
+
+function fleetopsCommandsBoot(): SQLiteConnection
+{
+    $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
+    $resolver   = new ConnectionResolver(['default' => $connection, 'mysql' => $connection, 'sandbox' => $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);
+        }
+    });
+    app()->instance('db.schema', $connection->getSchemaBuilder());
+    Illuminate\Support\Facades\DB::clearResolvedInstance('db');
+    Illuminate\Support\Facades\Schema::clearResolvedInstance('db.schema');
+
+    $schema = $connection->getSchemaBuilder();
+    $tables = [
+        'service_quotes' => ['uuid', 'public_id', 'company_uuid', 'service_rate_uuid', 'amount', 'currency', 'expired_at'],
+        'purchase_rates' => ['uuid', 'public_id', 'company_uuid', 'service_quote_uuid', 'status'],
+        'orders'         => ['uuid', 'public_id', 'company_uuid', 'status', 'dispatched', 'dispatched_at', 'scheduled_at', 'type'],
+    ];
+    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']);
+    FleetOpsCommandsTestRecorder::$dispatched = [];
+    FleetOpsCommandsTestRecorder::$events     = [];
+
+    return $connection;
+}
+
+test('purge service quotes deletes stale unpurchased quotes', function () {
+    $connection = fleetopsCommandsBoot();
+    $connection->table('service_quotes')->insert([
+        ['uuid' => 'sq-old', 'company_uuid' => 'company-1', 'created_at' => now()->subDays(5)->toDateTimeString()],
+        ['uuid' => 'sq-purchased', 'company_uuid' => 'company-1', 'created_at' => now()->subDays(5)->toDateTimeString()],
+        ['uuid' => 'sq-fresh', 'company_uuid' => 'company-1', 'created_at' => now()->toDateTimeString()],
+    ]);
+    $connection->table('purchase_rates')->insert(['uuid' => 'pr-1', 'service_quote_uuid' => 'sq-purchased']);
+
+    $command = new FleetOpsPurgeQuotesCommandProbe();
+    $result  = $command->handle();
+
+    expect($result)->toBe(Command::SUCCESS)
+        ->and($connection->table('service_quotes')->count())->toBe(2)
+        ->and($connection->table('service_quotes')->where('uuid', 'sq-old')->exists())->toBeFalse()
+        ->and($command->messages[0][1])->toContain('Successfully deleted 1');
+});
+
+test('purge service quotes reports empty runs', function () {
+    fleetopsCommandsBoot();
+
+    $command = new FleetOpsPurgeQuotesCommandProbe();
+    $result  = $command->handle();
+
+    expect($result)->toBe(Command::SUCCESS)
+        ->and($command->messages[0][1])->toContain('No unpurchased service quotes');
+});
+
+test('purge service quotes rolls back and reports failures', function () {
+    fleetopsCommandsBoot();
+
+    $command              = new FleetOpsPurgeQuotesCommandProbe();
+    $command->purgeThrows = true;
+    $result               = $command->handle();
+
+    expect($result)->toBe(Command::FAILURE)
+        ->and($command->messages[0][0])->toBe('error')
+        ->and($command->messages[0][1])->toContain('purge failed');
+});
+
+test('dispatch orders dispatches ready orders and warns for unready ones', function () {
+    $connection = fleetopsCommandsBoot();
+    $connection->table('orders')->insert([
+        [
+            'uuid'         => 'order-ready',
+            'public_id'    => 'order_ready',
+            'company_uuid' => 'company-1',
+            'status'       => 'created',
+            'dispatched'   => '0',
+            'scheduled_at' => now()->toDateTimeString(),
+        ],
+        [
+            'uuid'         => 'order-later',
+            'public_id'    => 'order_later',
+            'company_uuid' => 'company-1',
+            'status'       => 'created',
+            'dispatched'   => '0',
+            'scheduled_at' => now()->addHours(6)->toDateTimeString(),
+        ],
+    ]);
+
+    $command = new FleetOpsDispatchOrdersCommandProbe();
+    $command->handle();
+
+    $levels = collect($command->messages)->pluck(0);
+    expect($levels)->toContain('alert')
+        ->and($connection->table('orders')->where('uuid', 'order-ready')->value('dispatched'))->toBe('1')
+        ->and($connection->table('orders')->where('uuid', 'order-later')->value('dispatched'))->toBe('0');
+});