@fleetbase/fleetops-engine 0.6.58 → 0.6.59

package/server/tests/Feature/Http/Internal/MetricsControllerContractsTest.php

@@ -0,0 +1,249 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\MetricsController;
+use Illuminate\Http\Request;
+use Illuminate\Support\Carbon;
+use Illuminate\Support\Stringable;
+
+class FleetOpsInternalMetricsControllerProbe extends MetricsController
+{
+    public ?string $metricClass = FleetOpsInternalMetricFake::class;
+    public FleetOpsInternalMetricsCollectionFake $metrics;
+    public FleetOpsInternalMetricFake $metric;
+    public array $bulkCalls       = [];
+    public array $metricCalls     = [];
+    public ?Throwable $bulkError  = null;
+    public array $resolvedPeriods = [];
+
+    public function __construct()
+    {
+        $this->metrics = new FleetOpsInternalMetricsCollectionFake();
+        $this->metric  = new FleetOpsInternalMetricFake();
+    }
+
+    protected function metricsForCompany($company, $start, $end): FleetOpsInternalMetricsCollectionFake
+    {
+        $this->bulkCalls[] = compact('company', 'start', 'end');
+
+        if ($this->bulkError) {
+            throw $this->bulkError;
+        }
+
+        return $this->metrics;
+    }
+
+    protected function resolveMetricClass(string $slug): ?string
+    {
+        return $this->metricClass;
+    }
+
+    protected function metricForCompany(string $class, $company): FleetOpsInternalMetricFake
+    {
+        $this->metricCalls[] = compact('class', 'company');
+
+        return $this->metric;
+    }
+
+    protected function resolvePeriod(Request $request): array
+    {
+        $period = parent::resolvePeriod($request);
+
+        $this->resolvedPeriods[] = array_map(
+            fn ($date) => $date instanceof DateTimeInterface ? $date->format('Y-m-d H:i:s') : $date,
+            $period
+        );
+
+        return $period;
+    }
+}
+
+class FleetOpsInternalMetricsCollectionFake
+{
+    public array $discoveries = [];
+    public array $data        = ['orders_completed' => 12, 'earnings' => 4500];
+
+    public function with(array $discover): static
+    {
+        $this->discoveries[] = $discover;
+
+        return $this;
+    }
+
+    public function get(): array
+    {
+        return $this->data;
+    }
+}
+
+class FleetOpsInternalMetricFake
+{
+    public array $betweenCalls    = [];
+    public array $compareCalls    = [];
+    public array $sparklineCalls  = [];
+    public array $data            = ['slug' => 'orders_completed', 'value' => 12, 'format' => 'number'];
+
+    public static function forCompany($company): static
+    {
+        return new static();
+    }
+
+    public function between(DateTimeInterface $start, DateTimeInterface $end): static
+    {
+        $this->betweenCalls[] = [$start->format('Y-m-d H:i:s'), $end->format('Y-m-d H:i:s')];
+
+        return $this;
+    }
+
+    public function compareTo(DateTimeInterface $start, DateTimeInterface $end): static
+    {
+        $this->compareCalls[] = [$start->format('Y-m-d H:i:s'), $end->format('Y-m-d H:i:s')];
+
+        return $this;
+    }
+
+    public function withSparkline(int $buckets, string $unit): static
+    {
+        $this->sparklineCalls[] = [$buckets, $unit];
+
+        return $this;
+    }
+
+    public function get(): array
+    {
+        return $this->data;
+    }
+}
+
+class FleetOpsInternalMetricsRequestFake extends Request
+{
+    public function __construct(private array $values = [], private ?object $user = null)
+    {
+        parent::__construct($values);
+    }
+
+    public function user($guard = null): ?object
+    {
+        return $this->user;
+    }
+
+    public function string($key = null, $default = null): Stringable
+    {
+        return str((string) ($this->values[$key] ?? $default ?? ''));
+    }
+
+    public function array($key = null, $default = []): array
+    {
+        $value = $this->values[$key] ?? $default;
+
+        return is_array($value) ? $value : $default;
+    }
+
+    public function boolean($key = null, $default = false): bool
+    {
+        return filter_var($this->values[$key] ?? $default, FILTER_VALIDATE_BOOLEAN);
+    }
+
+    public function input($key = null, $default = null): mixed
+    {
+        return $key === null ? $this->values : ($this->values[$key] ?? $default);
+    }
+
+    public function date($key = null, $format = null, $tz = null): ?Carbon
+    {
+        if (!array_key_exists($key, $this->values) || $this->values[$key] === null) {
+            return null;
+        }
+
+        return Carbon::parse($this->values[$key], $tz);
+    }
+}
+
+function fleetopsInternalMetricsUser(): object
+{
+    return (object) [
+        'company' => (object) [
+            'uuid' => 'company-uuid',
+            'name' => 'Fleetbase Test Co',
+        ],
+    ];
+}
+
+test('internal metrics controller returns legacy bulk metrics and discovery selections', function () {
+    $controller = new FleetOpsInternalMetricsControllerProbe();
+    $request    = new FleetOpsInternalMetricsRequestFake([
+        'start'    => '2026-07-01 00:00:00',
+        'end'      => '2026-07-31 23:59:59',
+        'discover' => ['orders_completed', 'earnings'],
+    ], fleetopsInternalMetricsUser());
+
+    $response = $controller->all($request);
+
+    expect($response->getData(true))->toBe(['orders_completed' => 12, 'earnings' => 4500])
+        ->and($controller->metrics->discoveries)->toBe([['orders_completed', 'earnings']])
+        ->and($controller->bulkCalls[0]['company']->uuid)->toBe('company-uuid')
+        ->and($controller->bulkCalls[0]['start']->format('Y-m-d H:i:s'))->toBe('2026-07-01 00:00:00')
+        ->and($controller->bulkCalls[0]['end']->format('Y-m-d H:i:s'))->toBe('2026-07-31 23:59:59');
+});
+
+test('internal metrics controller converts bulk metric exceptions into error responses', function () {
+    $controller            = new FleetOpsInternalMetricsControllerProbe();
+    $controller->bulkError = new RuntimeException('Metrics backend unavailable.');
+
+    $response = $controller->all(new FleetOpsInternalMetricsRequestFake([], fleetopsInternalMetricsUser()));
+
+    expect($response->getData(true))->toBe(['error' => 'Metrics backend unavailable.'])
+        ->and($response->getStatusCode())->toBe(500);
+});
+
+test('internal metrics controller reports unknown metric slugs', function () {
+    $controller              = new FleetOpsInternalMetricsControllerProbe();
+    $controller->metricClass = null;
+
+    $response = $controller->show(new FleetOpsInternalMetricsRequestFake([], fleetopsInternalMetricsUser()), 'missing_metric');
+
+    expect($response->getStatusCode())->toBe(404)
+        ->and($response->getData(true))->toBe(['error' => 'Unknown metric: missing_metric']);
+});
+
+test('internal metrics controller applies compare and sparkline options for metric payloads', function () {
+    Carbon::setTestNow(Carbon::parse('2026-07-27 12:00:00'));
+
+    try {
+        $controller = new FleetOpsInternalMetricsControllerProbe();
+        $request    = new FleetOpsInternalMetricsRequestFake([
+            'period'            => '7d',
+            'compare'           => true,
+            'sparkline'         => true,
+            'sparkline_buckets' => 9,
+        ], fleetopsInternalMetricsUser());
+
+        $response = $controller->show($request, 'orders_completed');
+
+        expect($response->getData(true))->toBe(['slug' => 'orders_completed', 'value' => 12, 'format' => 'number'])
+            ->and($controller->metricCalls)->toHaveCount(1)
+            ->and($controller->metricCalls[0]['class'])->toBe(FleetOpsInternalMetricFake::class)
+            ->and($controller->metricCalls[0]['company']->uuid)->toBe('company-uuid')
+            ->and($controller->metric->betweenCalls)->toBe([['2026-07-20 12:00:00', '2026-07-27 12:00:00']])
+            ->and($controller->metric->compareCalls)->toBe([['2026-07-13 12:00:00', '2026-07-20 12:00:00']])
+            ->and($controller->metric->sparklineCalls)->toBe([[9, 'day']])
+            ->and($controller->resolvedPeriods)->toBe([['2026-07-20 12:00:00', '2026-07-27 12:00:00']]);
+    } finally {
+        Carbon::setTestNow();
+    }
+});
+
+test('internal metrics controller skips compare and uses explicit windows when requested', function () {
+    $controller = new FleetOpsInternalMetricsControllerProbe();
+    $request    = new FleetOpsInternalMetricsRequestFake([
+        'start'   => '2026-06-01 00:00:00',
+        'end'     => '2026-06-30 23:59:59',
+        'compare' => false,
+    ], fleetopsInternalMetricsUser());
+
+    $response = $controller->show($request, 'orders_completed');
+
+    expect($response->getStatusCode())->toBe(200)
+        ->and($controller->metric->betweenCalls)->toBe([['2026-06-01 00:00:00', '2026-06-30 23:59:59']])
+        ->and($controller->metric->compareCalls)->toBe([])
+        ->and($controller->metric->sparklineCalls)->toBe([]);
+});

package/server/tests/Feature/Http/Internal/MetricsControllerHelpersTest.php

@@ -0,0 +1,66 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\MetricsController;
+use Fleetbase\FleetOps\Support\Metrics;
+use Fleetbase\FleetOps\Support\Metrics\Registry;
+use Fleetbase\Models\Company;
+use Illuminate\Http\Request;
+use Illuminate\Support\Carbon;
+
+/**
+ * Covers the MetricsController protected helpers: metric container and
+ * per-class construction, registry slug resolution, and period parsing
+ * shorthand branches.
+ */
+function fleetopsMetricsHelpersCompany(): Company
+{
+    $company = new Company();
+    $company->setRawAttributes(['uuid' => 'company-metrics-1', 'public_id' => 'company_metrics', 'name' => 'Metrics Co'], true);
+
+    return $company;
+}
+
+test('metrics helpers construct metric containers and resolve periods', function () {
+    Carbon::setTestNow(Carbon::parse('2026-07-20 12:00:00'));
+
+    $controller = new MetricsController();
+    $helper     = function (string $method, ...$arguments) use ($controller) {
+        $reflection = new ReflectionMethod(MetricsController::class, $method);
+        $reflection->setAccessible(true);
+
+        return $reflection->invoke($controller, ...$arguments);
+    };
+
+    $company = fleetopsMetricsHelpersCompany();
+
+    // The container and per-metric factories construct without querying
+    expect($helper('metricsForCompany', $company, Carbon::now()->subDays(7)->toDateTime(), Carbon::now()->toDateTime()))->toBeInstanceOf(Metrics::class);
+
+    $slug = collect(Registry::slugs())->first();
+    if ($slug) {
+        $class = $helper('resolveMetricClass', $slug);
+        expect($class)->toBeString()
+            ->and($helper('metricForCompany', $class, $company))->not->toBeNull();
+    }
+    expect($helper('resolveMetricClass', 'not-a-real-metric'))->toBeNull();
+
+    // Period shorthand branches
+    foreach (['7d' => 7, '14d' => 14, '30d' => 30, '90d' => 90, '180d' => 180, '365d' => 365] as $period => $days) {
+        [$start, $end] = $helper('resolvePeriod', Request::create('/int/v1/metrics', 'GET', ['period' => $period]));
+        expect(Carbon::instance($start)->toDateString())->toBe(Carbon::parse('2026-07-20')->subDays($days)->toDateString());
+    }
+    [$start, $end] = $helper('resolvePeriod', Request::create('/int/v1/metrics', 'GET', ['period' => '90d']));
+    expect(Carbon::instance($start)->toDateString())->toBe('2026-04-21')
+        ->and(Carbon::instance($end)->toDateString())->toBe('2026-07-20');
+
+    // Unknown shorthand falls through to explicit dates and defaults
+    [$start, $end] = $helper('resolvePeriod', Request::create('/int/v1/metrics', 'GET', ['period' => 'quarterly', 'start' => '2026-06-01', 'end' => '2026-06-15']));
+    expect(Carbon::instance($start)->toDateString())->toBe('2026-06-01')
+        ->and(Carbon::instance($end)->toDateString())->toBe('2026-06-15');
+
+    [$start, $end] = $helper('resolvePeriod', Request::create('/int/v1/metrics', 'GET'));
+    expect(Carbon::instance($start)->toDateString())->toBe('2026-06-20')
+        ->and(Carbon::instance($end)->toDateString())->toBe('2026-07-20');
+
+    Carbon::setTestNow();
+});

package/server/tests/Feature/Http/Internal/MorphControllerHelpersTest.php

@@ -0,0 +1,125 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\MorphController;
+use Fleetbase\FleetOps\Models\Contact;
+use Fleetbase\FleetOps\Models\Vendor;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Http\Request;
+
+/**
+ * Covers the MorphController protected helper bodies: query builders for
+ * contacts, vendors and integrated vendors, paginator construction, input
+ * normalization, url/json helpers and the contact/vendor resource wrappers.
+ */
+if (!class_exists('Illuminate\\Pagination\\LengthAwarePaginator', false)) {
+    eval('namespace Illuminate\\Pagination; class LengthAwarePaginator { public function __construct(public $items = [], public int $total = 0, public int $perPage = 15, public int $currentPage = 1, public array $options = []) {} public function total(): int { return $this->total; } public function perPage(): int { return $this->perPage; } public function __call($method, $arguments) { return $this; } }');
+}
+
+function fleetopsMorphHelpersBoot(): SQLiteConnection
+{
+    $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
+    $resolver   = new ConnectionResolver(['default' => $connection, 'mysql' => $connection]);
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+    app()->instance('db', new class($connection) {
+        public function __construct(public SQLiteConnection $c)
+        {
+        }
+
+        public function connection($name = null): SQLiteConnection
+        {
+            return $this->c;
+        }
+
+        public function __call($method, $arguments)
+        {
+            return $this->c->{$method}(...$arguments);
+        }
+    });
+    Illuminate\Support\Facades\DB::clearResolvedInstance('db');
+
+    $schema = $connection->getSchemaBuilder();
+    $tables = [
+        'contacts'           => ['uuid', 'public_id', 'company_uuid', 'user_uuid', 'name', 'email', 'phone', 'type', 'meta', '_key'],
+        'vendors'            => ['uuid', 'public_id', 'company_uuid', 'name', 'email', 'phone', 'type', 'meta', '_key'],
+        'integrated_vendors' => ['uuid', 'public_id', 'company_uuid', 'provider', 'credentials', 'options', 'sandbox', 'status', '_key'],
+    ];
+    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']);
+    app()->instance('request', Request::create('/int/v1/morph-search', 'GET'));
+    if (!app()->bound('url')) {
+        app()->instance('url', new class {
+            public function current()
+            {
+                return 'https://fleetops.test/int/v1/morph-search';
+            }
+
+            public function __call($method, $arguments)
+            {
+                return 'https://fleetops.test/int/v1/morph-search';
+            }
+        });
+    }
+    Illuminate\Support\Facades\URL::clearResolvedInstance('url');
+
+    return $connection;
+}
+
+test('morph controller helpers build queries paginators inputs and resources', function () {
+    $connection = fleetopsMorphHelpersBoot();
+    $connection->table('contacts')->insert(['uuid' => 'contact-morph-1', 'company_uuid' => 'company-1', 'name' => 'Morph Contact']);
+    $connection->table('vendors')->insert(['uuid' => 'vendor-morph-1', 'company_uuid' => 'company-1', 'name' => 'Morph Vendor']);
+    $connection->table('integrated_vendors')->insert(['uuid' => 'iv-morph-1', 'company_uuid' => 'company-1', 'provider' => 'lalamove']);
+
+    $controller = new MorphController();
+    $helper     = function (string $method, ...$arguments) use ($controller) {
+        $reflection = new ReflectionMethod(MorphController::class, $method);
+        $reflection->setAccessible(true);
+
+        return $reflection->invoke($controller, ...$arguments);
+    };
+
+    // Query builders hit their base tables
+    expect($helper('newContactQuery')->count())->toBe(1)
+        ->and($helper('newVendorQuery')->count())->toBe(1)
+        ->and($helper('newIntegratedVendorQuery', 'company-1')->count())->toBe(1)
+        ->and($helper('newIntegratedVendorQuery', 'company-2')->count())->toBe(0);
+
+    // Paginator construction keeps totals and page geometry
+    $paginator = $helper('newLengthAwarePaginator', collect(['a', 'b']), 10, 2, 1, ['path' => '/int/v1/morph-search']);
+    expect($paginator)->toBeInstanceOf('Illuminate\\Pagination\\LengthAwarePaginator')
+        ->and($paginator->total())->toBe(10)
+        ->and($paginator->perPage())->toBe(2);
+
+    // Input normalization coerces scalars and null into arrays
+    $request = Request::create('/int/v1/morph-search', 'GET', ['one' => 'value', 'many' => ['a', 'b'], 'blank' => null, 'filled' => 'yes']);
+    expect($helper('arrayInput', $request, 'one'))->toBe(['value'])
+        ->and($helper('arrayInput', $request, 'many'))->toBe(['a', 'b'])
+        ->and($helper('arrayInput', $request, 'blank'))->toBe([])
+        ->and($helper('firstInput', $request, ['missing', 'filled']))->toBe('yes')
+        ->and($helper('firstInput', $request, ['missing', 'blank']))->toBeNull();
+
+    // Url + json helpers proxy the framework services
+    expect($helper('currentUrl'))->toContain('morph-search')
+        ->and($helper('jsonResponse', ['ok' => true]))->toBeInstanceOf(Illuminate\Http\JsonResponse::class);
+
+    // Resource wrappers accept models and collections
+    $contact = Contact::where('uuid', 'contact-morph-1')->first();
+    $vendor  = Vendor::where('uuid', 'vendor-morph-1')->first();
+    expect($helper('contactResource', $contact))->toBeInstanceOf(Fleetbase\FleetOps\Http\Resources\v1\Contact::class)
+        ->and($helper('vendorResource', $vendor))->toBeInstanceOf(Fleetbase\FleetOps\Http\Resources\v1\Vendor::class)
+        ->and($helper('contactResourceCollection', collect([$contact])))->toBeInstanceOf(Illuminate\Http\Resources\Json\ResourceCollection::class)
+        ->and($helper('vendorResourceCollection', collect([$vendor])))->toBeInstanceOf(Illuminate\Http\Resources\Json\ResourceCollection::class);
+});

package/server/tests/Feature/Http/Internal/NavigatorControllerHelpersTest.php

@@ -0,0 +1,201 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\NavigatorController;
+use Fleetbase\Models\ApiCredential;
+use Fleetbase\Models\Company;
+use Fleetbase\Models\User;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+/**
+ * Covers the real bodies of the internal NavigatorController's protected
+ * helper methods: admin lookup, navigator credential creation, deep-link
+ * configuration values, redirects, api-credential token resolution,
+ * organization lookup, and driver onboard settings.
+ */
+if (!function_exists('url')) {
+    function url(?string $path = null)
+    {
+        if ($path === null) {
+            return new class {
+                public function secure(string $path = '/'): string
+                {
+                    return 'https://fleetbase.test' . $path;
+                }
+            };
+        }
+
+        return 'https://fleetbase.test/' . ltrim($path, '/');
+    }
+}
+
+if (!function_exists('Fleetbase\FleetOps\Http\Controllers\Internal\v1\env')) {
+    eval('namespace Fleetbase\FleetOps\Http\Controllers\Internal\v1; function env($key, $default = null) { return \FleetOpsNavigatorHelpersEnv::$values[$key] ?? $default; }');
+}
+
+class FleetOpsNavigatorHelpersEnv
+{
+    public static array $values = [];
+}
+
+class FleetOpsNavigatorHelpersRedirectFake
+{
+    public array $urls = [];
+
+    public function away(string $url): string
+    {
+        $this->urls[] = $url;
+
+        return 'redirected:' . $url;
+    }
+}
+
+class FleetOpsInternalNavigatorHelpersProbe extends NavigatorController
+{
+    public function callProtected(string $method, array $arguments = []): mixed
+    {
+        $reflection = new ReflectionMethod(NavigatorController::class, $method);
+        $reflection->setAccessible(true);
+
+        return $reflection->invoke($this, ...$arguments);
+    }
+}
+
+function fleetopsInternalNavigatorHelpersBoot(): 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);
+        }
+    });
+    Illuminate\Support\Facades\DB::clearResolvedInstance('db');
+
+    $schema = $connection->getSchemaBuilder();
+    $tables = [
+        'users'           => ['uuid', 'public_id', 'company_uuid', 'type', 'name', 'email', 'phone'],
+        'companies'       => ['uuid', 'public_id', 'name', 'owner_uuid'],
+        'api_credentials' => ['uuid', 'public_id', 'user_uuid', 'company_uuid', 'name', 'key', 'secret', 'expires_at', 'last_used_at'],
+        'settings'        => ['key', 'value'],
+    ];
+    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('admin lookup and navigator credential helpers execute against the database', function () {
+    $connection = fleetopsInternalNavigatorHelpersBoot();
+    $connection->table('companies')->insert(['uuid' => 'company-1', 'name' => 'Acme']);
+    $connection->table('users')->insert(['uuid' => 'user-1', 'company_uuid' => 'company-1', 'type' => 'admin']);
+
+    $probe = new FleetOpsInternalNavigatorHelpersProbe();
+
+    $admin = $probe->callProtected('findAdminUser');
+    expect($admin)->toBeInstanceOf(User::class)
+        ->and($admin->uuid)->toBe('user-1');
+
+    $credential = $probe->callProtected('firstOrCreateNavigatorCredential', [$admin]);
+    expect($credential)->toBeInstanceOf(ApiCredential::class)
+        ->and($connection->table('api_credentials')->count())->toBe(1)
+        ->and($connection->table('api_credentials')->value('name'))->toBe('NavigationAppLinker');
+
+    // Re-invocation reuses the existing credential
+    $probe->callProtected('firstOrCreateNavigatorCredential', [$admin]);
+    expect($connection->table('api_credentials')->count())->toBe(1);
+});
+
+test('deep link configuration helpers read url config and environment values', function () {
+    fleetopsInternalNavigatorHelpersBoot();
+    FleetOpsNavigatorHelpersEnv::$values = [
+        'SOCKETCLUSTER_HOST'   => 'socket.fleetbase.test',
+        'SOCKETCLUSTER_PORT'   => 38000,
+        'SOCKETCLUSTER_SECURE' => 'true',
+    ];
+
+    $probe = new FleetOpsInternalNavigatorHelpersProbe();
+
+    expect($probe->callProtected('secureRootUrl'))->toBe('https://fleetbase.test/')
+        ->and($probe->callProtected('navigatorAppIdentifier'))->toBe('io.fleetbase.navigator')
+        ->and($probe->callProtected('socketClusterHost'))->toBe('socket.fleetbase.test')
+        ->and($probe->callProtected('socketClusterPort'))->toBe(38000)
+        ->and($probe->callProtected('socketClusterSecure'))->toBeTrue();
+
+    FleetOpsNavigatorHelpersEnv::$values = [];
+    expect($probe->callProtected('socketClusterHost'))->toBe('socket')
+        ->and($probe->callProtected('socketClusterPort'))->toBe(8000)
+        ->and($probe->callProtected('socketClusterSecure'))->toBeFalse();
+});
+
+test('redirect away helper delegates to the redirector', function () {
+    fleetopsInternalNavigatorHelpersBoot();
+    $redirect = new FleetOpsNavigatorHelpersRedirectFake();
+    app()->instance('redirect', $redirect);
+    Illuminate\Support\Facades\Redirect::clearResolvedInstance('redirect');
+
+    $result = (new FleetOpsInternalNavigatorHelpersProbe())->callProtected('redirectAway', ['flbnavigator://configure?key=abc']);
+
+    expect($result)->toBe('redirected:flbnavigator://configure?key=abc')
+        ->and($redirect->urls)->toBe(['flbnavigator://configure?key=abc']);
+});
+
+test('api credential token resolution finds keys and secrets', function () {
+    $connection = fleetopsInternalNavigatorHelpersBoot();
+    $connection->table('companies')->insert(['uuid' => 'company-1', 'name' => 'Acme']);
+    $connection->table('api_credentials')->insert([
+        'uuid'         => 'cred-1',
+        'company_uuid' => 'company-1',
+        'key'          => 'flb_live_abc',
+        'secret'       => '$secret_abc',
+    ]);
+
+    $probe = new FleetOpsInternalNavigatorHelpersProbe();
+
+    $byKey = $probe->callProtected('findApiCredentialForToken', ['flb_live_abc', 'mysql', false]);
+    expect($byKey)->toBeInstanceOf(ApiCredential::class)
+        ->and($byKey->uuid)->toBe('cred-1');
+
+    $bySecret = $probe->callProtected('findApiCredentialForToken', ['$secret_abc', 'mysql', true]);
+    expect($bySecret)->toBeInstanceOf(ApiCredential::class);
+
+    expect($probe->callProtected('findApiCredentialForToken', ['missing', 'mysql', false]))->toBeNull();
+});
+
+test('organization and driver onboard settings helpers execute against the database', function () {
+    $connection = fleetopsInternalNavigatorHelpersBoot();
+    $connection->table('companies')->insert(['uuid' => 'company-1', 'name' => 'Acme']);
+    $connection->table('settings')->insert(['key' => 'fleet-ops.driver-onboard', 'value' => json_encode(['enabled' => true])]);
+
+    $probe = new FleetOpsInternalNavigatorHelpersProbe();
+
+    $organization = $probe->callProtected('findOrganization', ['company-1']);
+    expect($organization)->toBeInstanceOf(Company::class)
+        ->and($organization->name)->toBe('Acme');
+
+    $settings = $probe->callProtected('driverOnboardSettings');
+    expect($settings)->not->toBeNull();
+});