@fleetbase/fleetops-engine 0.6.58 → 0.6.59

package/server/tests/Feature/Http/Api/DriverControllerAuthFlowsTest.php

@@ -0,0 +1,451 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Controllers\Api\v1\DriverController;
+use Fleetbase\FleetOps\Http\Resources\v1\Driver as DriverResource;
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\Models\User;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+/**
+ * Covers the API DriverController authentication flows against SQLite:
+ * password login with wrong-password and token-issuing branches, the
+ * phone-login SMS attempt with email fallback and no-channel error, and
+ * verification-code checking with invalid/bypass/valid variants.
+ *
+ * The `users.driver` relation used by whereHas('driver') is registered
+ * through the core Expandable expand() mechanism — the core model's __call
+ * forwards unknown methods to the query builder, bypassing Eloquent's
+ * relation resolvers.
+ */
+/**
+ * Nothing binds `twilio` in the harness, so the core SmsService fails and every
+ * phone login falls back to email. Binding this fake lets the SMS branch run.
+ */
+class FleetOpsDriverAuthTwilioFake
+{
+    public array $messages = [];
+
+    public function message($to, $text, $mediaUrls = [], $params = [])
+    {
+        $this->messages[] = [$to, $text];
+
+        return (object) ['sid' => 'SM-test-sid'];
+    }
+}
+
+class FleetOpsDriverAuthHasherFake implements Illuminate\Contracts\Hashing\Hasher
+{
+    public bool $checks = true;
+
+    public function info($hashedValue): array
+    {
+        return [];
+    }
+
+    public function make($value, array $options = []): string
+    {
+        return 'hashed-' . $value;
+    }
+
+    public function check($value, $hashedValue, array $options = []): bool
+    {
+        return $this->checks;
+    }
+
+    public function needsRehash($hashedValue, array $options = []): bool
+    {
+        return false;
+    }
+
+    public function verifyConfiguration($value): bool
+    {
+        return true;
+    }
+}
+
+class FleetOpsDriverAuthMailerFake
+{
+    public array $sent = [];
+
+    public function to($users)
+    {
+        return $this;
+    }
+
+    public function send($mailable)
+    {
+        $this->sent[] = $mailable;
+
+        return null;
+    }
+}
+
+function fleetopsDriverAuthBoot(): 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');
+
+    app()->instance('hash', new FleetOpsDriverAuthHasherFake());
+    Illuminate\Support\Facades\Hash::clearResolvedInstance('hash');
+
+    app()->instance('mail.manager', new FleetOpsDriverAuthMailerFake());
+    Illuminate\Support\Facades\Mail::clearResolvedInstance('mail.manager');
+
+    $schema = $connection->getSchemaBuilder();
+    $tables = [
+        'users'                  => ['uuid', 'public_id', 'company_uuid', 'name', 'email', 'phone', 'password', 'type', 'status', 'avatar_uuid'],
+        'drivers'                => ['uuid', 'public_id', 'internal_id', 'company_uuid', 'user_uuid', 'vehicle_uuid', 'status', 'online', 'auth_token', 'location', 'meta'],
+        'companies'              => ['uuid', 'public_id', 'name', 'options'],
+        'verification_codes'     => ['uuid', 'public_id', 'subject_uuid', 'subject_type', 'for', 'code', 'meta', 'status', 'expires_at'],
+        'personal_access_tokens' => ['tokenable_type', 'tokenable_id', 'name', 'token', 'abilities', 'last_used_at', 'expires_at'],
+    ];
+    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();
+        });
+    }
+
+    User::expand('driver', function () {
+        return $this->hasOne(Driver::class, 'user_uuid', 'uuid')->withoutGlobalScopes();
+    });
+
+    app()->forgetInstance('twilio');
+    Illuminate\Support\Facades\Facade::clearResolvedInstance('twilio');
+
+    session(['company' => 'company-1']);
+
+    $connection->table('users')->insert([
+        'uuid'         => 'user-1',
+        'company_uuid' => 'company-1',
+        'name'         => 'Driver One',
+        'email'        => 'driver@example.test',
+        'phone'        => '+6591234567',
+        'password'     => 'hashed-secret',
+    ]);
+    $connection->table('drivers')->insert([
+        'uuid'         => 'driver-1',
+        'public_id'    => 'driver_test',
+        'company_uuid' => 'company-1',
+        'user_uuid'    => 'user-1',
+    ]);
+    $connection->table('companies')->insert(['uuid' => 'company-1', 'public_id' => 'company_test', 'name' => 'Acme']);
+
+    return $connection;
+}
+
+test('password login rejects bad credentials and issues driver tokens', function () {
+    $connection = fleetopsDriverAuthBoot();
+    $controller = new DriverController();
+
+    // Wrong password
+    app('hash')->checks = false;
+    $rejected           = $controller->login(Request::create('/x', 'POST', ['identity' => 'driver@example.test', 'password' => 'nope']));
+    expect($rejected)->toBeInstanceOf(JsonResponse::class)
+        ->and($rejected->getStatusCode())->toBe(401)
+        ->and($rejected->getData(true)['error'])->toContain('Authentication failed');
+
+    // Correct password issues a personal access token on the driver resource
+    app('hash')->checks = true;
+    $resource           = $controller->login(Request::create('/x', 'POST', ['identity' => '6591234567', 'password' => 'secret']));
+    expect($resource)->toBeInstanceOf(DriverResource::class)
+        ->and($resource->token)->not->toBeEmpty()
+        ->and($connection->table('personal_access_tokens')->value('name'))->toBe('driver-1');
+});
+
+test('phone login falls back to email verification and errors without channels', function () {
+    $connection = fleetopsDriverAuthBoot();
+    $controller = new DriverController();
+
+    // Unknown phone number
+    app()->instance('request', Request::create('/x', 'POST', ['phone' => '+000']));
+    $missing = $controller->loginWithPhone();
+    expect($missing->getData(true)['error'])->toContain('No driver with this phone');
+
+    // SMS transport is unavailable in the harness, so the SMS attempt throws
+    // and the controller falls back to the mail-faked email channel.
+    app()->instance('request', Request::create('/x', 'POST', ['phone' => '6591234567']));
+    $emailFallback = $controller->loginWithPhone();
+    expect($emailFallback->getData(true))->toBe(['status' => 'OK', 'method' => 'email'])
+        ->and($connection->table('verification_codes')->where('for', 'driver_login')->count())->toBeGreaterThan(0);
+
+    // Without an email address no verification channel remains
+    $connection->table('users')->where('uuid', 'user-1')->update(['email' => null]);
+    $noChannel = $controller->loginWithPhone();
+    expect($noChannel->getData(true)['error'])->toContain('Unable to send SMS Verification code');
+});
+
+test('phone login reports the sms method when the transport delivers', function () {
+    $connection = fleetopsDriverAuthBoot();
+    $twilio     = new FleetOpsDriverAuthTwilioFake();
+    app()->instance('twilio', $twilio);
+    Fleetbase\Twilio\Support\Laravel\Facade::clearResolvedInstances();
+
+    app()->instance('request', Request::create('/x', 'POST', ['phone' => '6591234567']));
+    $response = (new DriverController())->loginWithPhone();
+
+    // No email fallback is attempted once the SMS itself goes out
+    expect($response->getData(true))->toBe(['status' => 'OK', 'method' => 'sms'])
+        ->and($twilio->messages)->toHaveCount(1)
+        ->and($twilio->messages[0][1])->toContain('Acme verification code is')
+        ->and($connection->table('verification_codes')->where('for', 'driver_login')->count())->toBe(1);
+});
+
+test('code verification handles unknown users invalid codes bypass and success', function () {
+    $connection = fleetopsDriverAuthBoot();
+    $controller = new DriverController();
+
+    // Unknown identity
+    $unknown = $controller->verifyCode(Request::create('/x', 'POST', ['identity' => 'ghost@example.test', 'code' => '123456']));
+    expect($unknown->getData(true)['error'])->toContain('Unable to verify code');
+
+    // Invalid code with no bypass configured
+    $invalid = $controller->verifyCode(Request::create('/x', 'POST', ['identity' => 'driver@example.test', 'code' => '999999']));
+    expect($invalid->getData(true)['error'])->toContain('Invalid verification code');
+
+    // Bypass code from config authenticates without a stored code
+    config()->set('fleetops.navigator.bypass_verification_code', '777777');
+    $bypassed = $controller->verifyCode(Request::create('/x', 'POST', ['identity' => 'driver@example.test', 'code' => '777777']));
+    expect($bypassed)->toBeInstanceOf(DriverResource::class);
+
+    // Stored verification codes authenticate and persist the auth token
+    $connection->table('verification_codes')->insert([
+        'uuid'         => 'vc-1',
+        'subject_uuid' => 'user-1',
+        'code'         => '424242',
+        'for'          => 'driver_login',
+    ]);
+    $verified = $controller->verifyCode(Request::create('/x', 'POST', ['identity' => '6591234567', 'code' => '424242']));
+    expect($verified)->toBeInstanceOf(DriverResource::class)
+        ->and($verified->token)->not->toBeEmpty()
+        ->and($connection->table('drivers')->where('uuid', 'driver-1')->value('auth_token'))->not->toBeEmpty();
+});
+
+test('verification failures report to sentry and exhaust every channel', function () {
+    $connection = fleetopsDriverAuthBoot();
+    $controller = new DriverController();
+
+    $sentry = new class {
+        public array $captured = [];
+
+        public function captureException($exception)
+        {
+            $this->captured[] = $exception;
+
+            return null;
+        }
+
+        public function __call($method, $arguments)
+        {
+            return null;
+        }
+    };
+    app()->instance('sentry', $sentry);
+
+    // The SMS attempt fails in the harness and is reported before the
+    // controller falls back to the email channel
+    app()->instance('request', Request::create('/x', 'POST', ['phone' => '6591234567']));
+    $emailFallback = $controller->loginWithPhone();
+    expect($emailFallback->getData(true))->toBe(['status' => 'OK', 'method' => 'email'])
+        ->and($sentry->captured)->toHaveCount(1);
+
+    // When the mail channel also fails both failures are reported and the
+    // controller surfaces the generic error
+    app()->instance('mail.manager', new class {
+        public function to($users)
+        {
+            return $this;
+        }
+
+        public function send($mailable)
+        {
+            throw new RuntimeException('mail transport unavailable');
+        }
+    });
+    Illuminate\Support\Facades\Mail::clearResolvedInstance('mail.manager');
+
+    $noChannel = $controller->loginWithPhone();
+    expect($noChannel->getData(true)['error'])->toContain('Unable to send SMS Verification code')
+        ->and(count($sentry->captured))->toBeGreaterThanOrEqual(3);
+
+    app()->forgetInstance('sentry');
+});
+
+test('verify code delegates driver creation requests to the create flow', function () {
+    fleetopsDriverAuthBoot();
+
+    $probe = new class extends DriverController {
+        public array $created = [];
+
+        public function create(Request $request)
+        {
+            $this->created[] = $request->input('identity');
+
+            return 'delegated-create';
+        }
+    };
+
+    $result = $probe->verifyCode(Request::create('/x', 'POST', [
+        'identity' => 'newdriver@example.test',
+        'code'     => '123456',
+        'for'      => 'create_driver',
+    ]));
+
+    expect($result)->toBe('delegated-create')
+        ->and($probe->created)->toBe(['newdriver@example.test']);
+});
+
+test('token issuance failures surface as api errors', function () {
+    $connection = fleetopsDriverAuthBoot();
+    $controller = new DriverController();
+
+    // Without the token table the sanctum call fails; the login endpoint
+    // reports the driver-facing error instead of leaking a query exception
+    $connection->getSchemaBuilder()->drop('personal_access_tokens');
+    app('hash')->checks = true;
+
+    $response = $controller->login(Request::create('/x', 'POST', [
+        'identity' => 'driver@example.test',
+        'password' => 'secret',
+    ]));
+
+    expect($response)->toBeInstanceOf(JsonResponse::class)
+        ->and($response->getData(true))->toHaveKey('error');
+});
+
+test('code verification reports token issuance failures', function () {
+    $connection = fleetopsDriverAuthBoot();
+    $controller = new DriverController();
+
+    // A bypass code authenticates without a stored verification code, so the
+    // flow reaches token issuance; without the token table that send fails
+    config()->set('fleetops.navigator.bypass_verification_code', '777777');
+    $connection->getSchemaBuilder()->drop('personal_access_tokens');
+
+    $response = $controller->verifyCode(Request::create('/x', 'POST', [
+        'identity' => 'driver@example.test',
+        'code'     => '777777',
+    ]));
+
+    expect($response)->toBeInstanceOf(JsonResponse::class)
+        ->and($response->getData(true))->toHaveKey('error');
+});
+
+test('token persistence failures are reported to sentry', function () {
+    $connection = fleetopsDriverAuthBoot();
+    $controller = new DriverController();
+
+    $sentry = new class {
+        public array $captured = [];
+
+        public function captureException($exception)
+        {
+            $this->captured[] = $exception;
+
+            return null;
+        }
+
+        public function __call($method, $arguments)
+        {
+            return null;
+        }
+    };
+    app()->instance('sentry', $sentry);
+
+    // Rebuild drivers without the auth_token column so persisting the issued
+    // token fails after the token itself was created successfully
+    $rows = $connection->table('drivers')->get();
+    $connection->getSchemaBuilder()->drop('drivers');
+    $connection->getSchemaBuilder()->create('drivers', function ($blueprint) {
+        $blueprint->increments('id');
+        foreach (['uuid', 'public_id', 'internal_id', 'company_uuid', 'user_uuid', 'vehicle_uuid', 'status', 'online', 'location', 'meta'] as $column) {
+            $blueprint->string($column)->nullable();
+        }
+        $blueprint->timestamps();
+        $blueprint->timestamp('deleted_at')->nullable();
+    });
+    foreach ($rows as $row) {
+        $connection->table('drivers')->insert([
+            'uuid'         => $row->uuid,
+            'public_id'    => $row->public_id,
+            'company_uuid' => $row->company_uuid,
+            'user_uuid'    => $row->user_uuid,
+        ]);
+    }
+
+    config()->set('fleetops.navigator.bypass_verification_code', '777777');
+    $response = $controller->verifyCode(Request::create('/x', 'POST', [
+        'identity' => 'driver@example.test',
+        'code'     => '777777',
+    ]));
+
+    expect($response->getData(true)['error'] ?? '')->toBe('Unable to authenticate driver.')
+        ->and($sentry->captured)->toHaveCount(1);
+
+    app()->forgetInstance('sentry');
+});
+
+test('current driver resolves the authenticated users driver profile', function () {
+    $connection = fleetopsDriverAuthBoot();
+    $connection->table('users')->insert(['uuid' => 'user-current-1', 'public_id' => 'user_current1', 'company_uuid' => 'company-1', 'name' => 'Current Driver', 'email' => 'current@example.test', 'type' => 'driver']);
+    $connection->table('drivers')->insert(['uuid' => 'driver-current-1', 'public_id' => 'driver_current1', 'company_uuid' => 'company-1', 'user_uuid' => 'user-current-1']);
+
+    // registerDevice without an id resolves the driver from the request user
+    // rather than a route parameter, so exercise the real seam here — the
+    // contract probe overrides it and never runs this body
+    $currentDriver = new ReflectionMethod(DriverController::class, 'currentDriver');
+    $currentDriver->setAccessible(true);
+
+    $request = Request::create('/v1/drivers/register-device', 'POST');
+    $request->setUserResolver(fn () => $connection->table('users')->where('uuid', 'user-current-1')->first());
+
+    $resolved = $currentDriver->invoke(new DriverController(), $request);
+
+    expect($resolved)->toBeInstanceOf(Driver::class)
+        ->and($resolved->uuid)->toBe('driver-current-1');
+});
+
+test('current driver fails when the request has no matching driver', function () {
+    fleetopsDriverAuthBoot();
+
+    $currentDriver = new ReflectionMethod(DriverController::class, 'currentDriver');
+    $currentDriver->setAccessible(true);
+
+    // A request with no authenticated user resolves no driver, which the
+    // caller turns into a not-found response instead of a 500
+    $failure = null;
+
+    try {
+        $currentDriver->invoke(new DriverController(), Request::create('/v1/drivers/register-device', 'POST'));
+    } catch (Illuminate\Database\Eloquent\ModelNotFoundException $exception) {
+        $failure = $exception;
+    }
+
+    expect($failure)->toBeInstanceOf(Illuminate\Database\Eloquent\ModelNotFoundException::class);
+});

package/server/tests/Feature/Http/Api/DriverControllerHelpersTest.php

@@ -0,0 +1,240 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Controllers\Api\v1\DriverController;
+use Fleetbase\FleetOps\Http\Resources\v1\DeletedResource;
+use Fleetbase\FleetOps\Http\Resources\v1\Driver as DriverResource;
+use Fleetbase\FleetOps\Jobs\SimulateDrivingRoute;
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Models\Payload;
+use Fleetbase\LaravelMysqlSpatial\Types\Point;
+use Fleetbase\TestSupport\DispatchRecorder;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+/**
+ * Exercises the real bodies of the API DriverController's protected helper
+ * methods and the self-contained route-simulation methods. The existing
+ * ApiDriverControllerContractsTest overrides these helpers on its probe, which
+ * leaves their real one-line implementations uncovered; here we invoke the
+ * genuine parent implementations through reflection so the underlying facade
+ * and resource calls execute.
+ */
+class FleetOpsApiDriverHelpersProbe extends DriverController
+{
+    public function callProtected(string $method, array $arguments = []): mixed
+    {
+        $reflection = new ReflectionMethod(DriverController::class, $method);
+        $reflection->setAccessible(true);
+
+        return $reflection->invoke($this, ...$arguments);
+    }
+}
+
+class FleetOpsApiDriverHelpersDriverFake extends Driver
+{
+    protected $guarded = [];
+    public $exists     = true;
+
+    public function __construct(array $attributes = [])
+    {
+        parent::__construct();
+        $this->setRawAttributes($attributes, true);
+    }
+}
+
+class FleetOpsApiDriverHelpersPlaceFake extends Fleetbase\FleetOps\Models\Place
+{
+    protected $guarded    = [];
+    public $exists        = true;
+    public ?Point $point  = null;
+
+    public static function at(Point $point): self
+    {
+        $place        = new self();
+        $place->point = $point;
+        $place->setRawAttributes(['uuid' => 'place-uuid'], true);
+
+        return $place;
+    }
+
+    public function getAttribute($key)
+    {
+        if ($key === 'location') {
+            return $this->point;
+        }
+
+        return parent::getAttribute($key);
+    }
+}
+
+class FleetOpsApiDriverHelpersPayloadFake extends Payload
+{
+    protected $guarded                               = [];
+    public $exists                                   = true;
+    public ?Fleetbase\FleetOps\Models\Place $pickup  = null;
+    public ?Fleetbase\FleetOps\Models\Place $dropoff = null;
+
+    public function __construct()
+    {
+        parent::__construct();
+        $this->setRawAttributes(['uuid' => 'payload-uuid'], true);
+    }
+
+    public function getPickupOrFirstWaypoint(): ?Fleetbase\FleetOps\Models\Place
+    {
+        return $this->pickup;
+    }
+
+    public function getDropoffOrLastWaypoint(): ?Fleetbase\FleetOps\Models\Place
+    {
+        return $this->dropoff;
+    }
+}
+
+class FleetOpsApiDriverHelpersOrderFake extends Order
+{
+    protected $guarded = [];
+    public $exists     = true;
+
+    public function __construct(array $attributes = [])
+    {
+        parent::__construct();
+        $this->setRawAttributes(array_merge(['uuid' => 'order-uuid'], $attributes), true);
+    }
+}
+
+function fleetopsApiDriverHelpersProbe(): FleetOpsApiDriverHelpersProbe
+{
+    return new FleetOpsApiDriverHelpersProbe();
+}
+
+function fleetopsApiDriverHelpersSeedRoute(Point $start, Point $end, array $route): void
+{
+    $key = 'getRoute:' . md5($start . $end . serialize([]));
+    Illuminate\Support\Facades\Cache::put($key, $route, 3600);
+}
+
+/*
+|--------------------------------------------------------------------------
+| Protected helper methods
+|--------------------------------------------------------------------------
+*/
+
+test('session company helper reads the company from the session store', function () {
+    session(['company' => 'company-abc']);
+
+    expect(fleetopsApiDriverHelpersProbe()->callProtected('sessionCompany'))->toBe('company-abc');
+});
+
+test('point from coordinates helper builds a spatial point', function () {
+    $point = fleetopsApiDriverHelpersProbe()->callProtected('pointFromCoordinates', [[
+        'latitude'  => 1.3521,
+        'longitude' => 103.8198,
+    ]]);
+
+    expect($point)->toBeInstanceOf(Point::class)
+        ->and($point->getLat())->toBe(1.3521)
+        ->and($point->getLng())->toBe(103.8198);
+});
+
+test('json response helper returns a json response with the supplied status', function () {
+    $response = fleetopsApiDriverHelpersProbe()->callProtected('jsonResponse', [['ok' => true], 201]);
+
+    expect($response)->toBeInstanceOf(JsonResponse::class)
+        ->and($response->getStatusCode())->toBe(201)
+        ->and($response->getData(true))->toBe(['ok' => true]);
+});
+
+test('driver resource helpers wrap drivers in their api resources', function () {
+    $driver = new FleetOpsApiDriverHelpersDriverFake(['uuid' => 'driver-uuid', 'public_id' => 'driver_test']);
+    $probe  = fleetopsApiDriverHelpersProbe();
+
+    expect($probe->callProtected('driverResource', [$driver]))->toBeInstanceOf(DriverResource::class)
+        ->and($probe->callProtected('deletedDriverResource', [$driver]))->toBeInstanceOf(DeletedResource::class)
+        ->and($probe->callProtected('driverResourceCollection', [[$driver]]))
+        ->toBeInstanceOf(Illuminate\Http\Resources\Json\ResourceCollection::class);
+});
+
+test('apply user info helper delegates to the user model helper', function () {
+    $request = Request::create('/fleet-ops/drivers', 'POST');
+
+    $result = fleetopsApiDriverHelpersProbe()->callProtected('applyUserInfoFromRequest', [$request, ['name' => 'Ada']]);
+
+    expect($result)->toBeArray()
+        ->and($result['name'])->toBe('Ada');
+});
+
+/*
+|--------------------------------------------------------------------------
+| Route simulation
+|--------------------------------------------------------------------------
+*/
+
+test('simulate driving for route returns the osrm payload when no route is found', function () {
+    DispatchRecorder::$dispatched = [];
+    $driver                       = new FleetOpsApiDriverHelpersDriverFake(['uuid' => 'driver-uuid']);
+    $start                        = new Point(1.0, 2.0);
+    $end                          = new Point(3.0, 4.0);
+    fleetopsApiDriverHelpersSeedRoute($start, $end, ['code' => 'NoRoute']);
+
+    $response = fleetopsApiDriverHelpersProbe()->simulateDrivingForRoute($driver, $start, $end);
+
+    expect($response)->toBeInstanceOf(JsonResponse::class)
+        ->and($response->getData(true))->toBe(['code' => 'NoRoute'])
+        ->and(DispatchRecorder::$dispatched)->toBe([]);
+});
+
+test('simulate driving for route dispatches the simulation job on a successful route', function () {
+    DispatchRecorder::$dispatched = [];
+    $driver                       = new FleetOpsApiDriverHelpersDriverFake(['uuid' => 'driver-uuid']);
+    $start                        = new Point(1.0, 2.0);
+    $end                          = new Point(3.0, 4.0);
+    fleetopsApiDriverHelpersSeedRoute($start, $end, ['code' => 'Ok', 'routes' => [['geometry' => 'ojfGx_zsAvBcH']]]);
+
+    $response = fleetopsApiDriverHelpersProbe()->simulateDrivingForRoute($driver, $start, $end);
+
+    expect($response)->toBeInstanceOf(JsonResponse::class)
+        ->and($response->getData(true)['code'])->toBe('Ok')
+        ->and(DispatchRecorder::$dispatched)->toHaveCount(1)
+        ->and(DispatchRecorder::$dispatched[0]['job'])->toBe(SimulateDrivingRoute::class);
+});
+
+test('simulate driving for order computes headings and dispatches the simulation job', function () {
+    DispatchRecorder::$dispatched = [];
+    $driver                       = new FleetOpsApiDriverHelpersDriverFake(['uuid' => 'driver-uuid']);
+    $payload                      = new FleetOpsApiDriverHelpersPayloadFake();
+    $payload->pickup              = FleetOpsApiDriverHelpersPlaceFake::at(new Point(1.0, 2.0));
+    $payload->dropoff             = FleetOpsApiDriverHelpersPlaceFake::at(new Point(3.0, 4.0));
+    $order                        = new FleetOpsApiDriverHelpersOrderFake();
+    $order->setRelation('payload', $payload);
+    $start = Fleetbase\FleetOps\Support\Utils::getPointFromMixed($payload->pickup);
+    $end   = Fleetbase\FleetOps\Support\Utils::getPointFromMixed($payload->dropoff);
+    fleetopsApiDriverHelpersSeedRoute($start, $end, ['code' => 'Ok', 'routes' => [['geometry' => 'ojfGx_zsAvBcH']]]);
+
+    $response = fleetopsApiDriverHelpersProbe()->simulateDrivingForOrder($driver, $order);
+
+    expect($response)->toBeInstanceOf(JsonResponse::class)
+        ->and($response->getData(true)['code'])->toBe('Ok')
+        ->and(DispatchRecorder::$dispatched)->toHaveCount(1)
+        ->and(DispatchRecorder::$dispatched[0]['job'])->toBe(SimulateDrivingRoute::class);
+});
+
+test('simulate driving for order returns the osrm payload when no route is found', function () {
+    DispatchRecorder::$dispatched = [];
+    $driver                       = new FleetOpsApiDriverHelpersDriverFake(['uuid' => 'driver-uuid']);
+    $payload                      = new FleetOpsApiDriverHelpersPayloadFake();
+    $payload->pickup              = FleetOpsApiDriverHelpersPlaceFake::at(new Point(5.0, 6.0));
+    $payload->dropoff             = FleetOpsApiDriverHelpersPlaceFake::at(new Point(7.0, 8.0));
+    $order                        = new FleetOpsApiDriverHelpersOrderFake();
+    $order->setRelation('payload', $payload);
+    $start = Fleetbase\FleetOps\Support\Utils::getPointFromMixed($payload->pickup);
+    $end   = Fleetbase\FleetOps\Support\Utils::getPointFromMixed($payload->dropoff);
+    fleetopsApiDriverHelpersSeedRoute($start, $end, ['code' => 'NoRoute']);
+
+    $response = fleetopsApiDriverHelpersProbe()->simulateDrivingForOrder($driver, $order);
+
+    expect($response)->toBeInstanceOf(JsonResponse::class)
+        ->and($response->getData(true))->toBe(['code' => 'NoRoute'])
+        ->and(DispatchRecorder::$dispatched)->toBe([]);
+});