@fleetbase/fleetops-engine 0.6.58 → 0.6.59

package/server/tests/SupportServiceContractsTest.php

@@ -0,0 +1,287 @@
+<?php
+
+use Fleetbase\FleetOps\Scopes\DriverScope;
+use Fleetbase\FleetOps\Support\LiveCacheService;
+use Fleetbase\FleetOps\Support\OSRM;
+use Fleetbase\LaravelMysqlSpatial\Types\Point;
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Support\Facades\Cache;
+use Illuminate\Support\Facades\Http;
+
+class FleetOpsTaggedCacheFake
+{
+    public array $calls = [];
+
+    public function __construct(private mixed $rememberValue = null, private bool $throwOnFlush = false)
+    {
+    }
+
+    public function remember($key, $ttl, Closure $callback)
+    {
+        $this->calls[] = ['remember', $key, $ttl];
+
+        return $this->rememberValue ?? $callback();
+    }
+
+    public function flush()
+    {
+        $this->calls[] = ['flush'];
+
+        if ($this->throwOnFlush) {
+            throw new RuntimeException('tagged cache is unavailable');
+        }
+    }
+}
+
+class FleetOpsLiveCacheFake
+{
+    public array $gets                           = [];
+    public array $increments                     = [];
+    public array $tags                           = [];
+    public ?FleetOpsTaggedCacheFake $taggedCache = null;
+    public bool $throwOnTags                     = false;
+    private array $versions                      = [
+        'live:company-1:orders:version'  => 3,
+        'live:company-1:drivers:version' => 1,
+    ];
+
+    public function get($key, $default = null)
+    {
+        $this->gets[] = [$key, $default];
+
+        return $this->versions[$key] ?? $default;
+    }
+
+    public function increment($key)
+    {
+        $this->increments[] = $key;
+
+        $this->versions[$key] = ($this->versions[$key] ?? 0) + 1;
+
+        return $this->versions[$key];
+    }
+
+    public function tags(array $tags)
+    {
+        $this->tags[] = $tags;
+
+        if ($this->throwOnTags) {
+            throw new RuntimeException('tagged cache is unavailable');
+        }
+
+        return $this->taggedCache ??= new FleetOpsTaggedCacheFake();
+    }
+}
+
+class FleetOpsDriverScopeBuilderFake extends Builder
+{
+    public array $whereHas = [];
+
+    public function __construct()
+    {
+    }
+
+    public function whereHas($relation, ?Closure $callback = null, $operator = '>=', $count = 1)
+    {
+        $this->whereHas[] = [$relation, $callback, $operator, $count];
+
+        return $this;
+    }
+}
+
+afterEach(function () {
+    Cache::swap(new Illuminate\Cache\Repository(new Illuminate\Cache\ArrayStore()));
+    Http::preventStrayRequests(false);
+});
+
+test('live cache service builds company scoped keys and tags', function () {
+    session(['company' => 'company-1']);
+
+    $cache = new FleetOpsLiveCacheFake();
+    Cache::swap($cache);
+
+    $params = ['active' => true, 'bounds' => [1, 2, 3, 4]];
+
+    expect(LiveCacheService::getCacheKey('orders', $params))
+        ->toBe('live:company-1:orders:v3:' . md5(json_encode($params)))
+        ->and(LiveCacheService::getTags())->toBe(['live:company-1'])
+        ->and(LiveCacheService::getEndpointTags('orders'))->toBe([
+            'live:company-1',
+            'live:company-1:orders',
+        ])
+        ->and($cache->gets)->toBe([['live:company-1:orders:version', 0]]);
+});
+
+test('live cache service increments versions and remembers tagged values', function () {
+    session(['company' => 'company-1']);
+
+    $cache              = new FleetOpsLiveCacheFake();
+    $cache->taggedCache = new FleetOpsTaggedCacheFake();
+    Cache::swap($cache);
+
+    expect(LiveCacheService::incrementVersion('drivers'))->toBe(2)
+        ->and(LiveCacheService::remember('drivers', ['limit' => 25], fn () => ['fresh' => true], 45))->toBe([
+            'fresh' => true,
+        ])
+        ->and($cache->increments)->toBe(['live:company-1:drivers:version'])
+        ->and($cache->tags)->toBe([['live:company-1', 'live:company-1:drivers']])
+        ->and($cache->taggedCache->calls)->toBe([
+            ['remember', 'live:company-1:drivers:v2:' . md5(json_encode(['limit' => 25])), 45],
+        ]);
+});
+
+test('live cache service invalidates endpoints with version bumps and optional tag flushes', function () {
+    session(['company' => 'company-1']);
+
+    $cache              = new FleetOpsLiveCacheFake();
+    $cache->taggedCache = new FleetOpsTaggedCacheFake();
+    Cache::swap($cache);
+
+    LiveCacheService::invalidate('vehicles');
+
+    expect($cache->increments)->toBe(['live:company-1:vehicles:version'])
+        ->and($cache->tags)->toBe([['live:company-1', 'live:company-1:vehicles']])
+        ->and($cache->taggedCache->calls)->toBe([['flush']]);
+
+    // Stores without tag support still get the version bump, which is what
+    // actually invalidates; the failed flush is swallowed.
+    $untagged              = new FleetOpsLiveCacheFake();
+    $untagged->throwOnTags = true;
+    Cache::swap($untagged);
+
+    LiveCacheService::invalidate('vehicles');
+
+    expect($untagged->increments)->toBe(['live:company-1:vehicles:version'])
+        ->and($untagged->tags)->toBe([['live:company-1', 'live:company-1:vehicles']]);
+});
+
+test('live cache service invalidates all endpoints and ignores unsupported tag flushes', function () {
+    session(['company' => 'company-1']);
+
+    $cache              = new FleetOpsLiveCacheFake();
+    $cache->throwOnTags = true;
+    Cache::swap($cache);
+
+    LiveCacheService::invalidate();
+
+    expect($cache->increments)->toBe([
+        'live:company-1:orders:version',
+        'live:company-1:routes:version',
+        'live:company-1:coordinates:version',
+        'live:company-1:drivers:version',
+        'live:company-1:vehicles:version',
+        'live:company-1:places:version',
+        'live:company-1:operations-monitor:version',
+    ])->and($cache->tags)->toBe([['live:company-1']]);
+});
+
+test('live cache service invalidates multiple endpoints and ignores tag flush failures', function () {
+    session(['company' => 'company-1']);
+
+    $cache              = new FleetOpsLiveCacheFake();
+    $cache->throwOnTags = true;
+    Cache::swap($cache);
+
+    LiveCacheService::invalidateMultiple(['orders', 'drivers']);
+
+    expect($cache->increments)->toBe([
+        'live:company-1:orders:version',
+        'live:company-1:drivers:version',
+    ])->and($cache->tags)->toBe([['live:company-1', 'live:company-1:orders']]);
+});
+
+test('driver scope requires an active user relationship', function () {
+    $builder = new FleetOpsDriverScopeBuilderFake();
+    $model   = new class extends Model {
+    };
+
+    expect((new DriverScope())->apply($builder, $model))->toBeNull()
+        ->and($builder->whereHas)->toHaveCount(1)
+        ->and($builder->whereHas[0][0])->toBe('user');
+});
+
+test('osrm decodes polyline route geometry fixtures', function () {
+    $points = OSRM::decodePolyline('_p~iF~ps|U_ulLnnqC_mqNvxq`@');
+
+    expect($points)->toHaveCount(3)
+        ->and($points[0])->toBeInstanceOf(Point::class)
+        ->and($points[0]->getLat())->toBe(-120.2)
+        ->and($points[0]->getLng())->toBe(38.5);
+});
+
+test('osrm support covers nearest table trip match tile and error fallback requests', function () {
+    Cache::swap(new Illuminate\Cache\Repository(new Illuminate\Cache\ArrayStore()));
+    app('config')->set('fleetops.osrm.host', 'https://osrm-other.test/');
+
+    Http::fake(function ($request) {
+        $url = (string) $request->url();
+
+        return match (true) {
+            str_contains($url, '/nearest/v1/driving/') => Http::response(['code' => 'Ok', 'waypoints' => [['name' => 'road']]]),
+            str_contains($url, '/table/v1/driving/')   => Http::response(['code' => 'Ok', 'durations' => [[0, 10], [10, 0]]]),
+            str_contains($url, '/trip/v1/driving/')    => Http::response(['code' => 'Ok', 'trips' => [['distance' => 100]]]),
+            str_contains($url, '/match/v1/driving/')   => Http::response(['code' => 'Ok', 'matchings' => [['confidence' => 1]]]),
+            str_contains($url, '/tile/v1/car/')        => Http::response('tile-bytes'),
+            str_contains($url, '/route/v1/driving/')   => throw new RuntimeException('timeout'),
+            default                                    => Http::response(['code' => 'Unexpected'], 500),
+        };
+    });
+
+    $points = [
+        new Point(1.30, 103.80),
+        new Point(1.31, 103.81),
+    ];
+
+    expect(OSRM::getNearest($points[0], ['number' => 1]))->toMatchArray(['code' => 'Ok'])
+        ->and(OSRM::getTable($points, ['annotations' => 'duration'])['durations'][0][1])->toBe(10)
+        ->and(OSRM::getTrip($points, ['roundtrip' => 'false'])['trips'][0]['distance'])->toBe(100)
+        ->and(OSRM::getMatch($points, ['geometries' => 'polyline'])['matchings'][0]['confidence'])->toBe(1)
+        ->and(OSRM::getTile(1, 2, 3, ['foo' => 'bar']))->toBe('tile-bytes')
+        ->and(OSRM::getRouteFromCoordinatesString('103.8,1.3;103.81,1.31'))->toBe(['code' => 'Error', 'routes' => []]);
+
+    expect(fn () => OSRM::getRouteFromPoints([$points[0]]))->toThrow(InvalidArgumentException::class, 'At least two points');
+});
+
+test('osrm converts mixed points decodes route polylines and serves cached results', function () {
+    Cache::swap(new Illuminate\Cache\Repository(new Illuminate\Cache\ArrayStore()));
+    app('config')->set('fleetops.osrm.host', 'https://osrm-mixed.test/');
+
+    Http::swap(new Illuminate\Http\Client\Factory());
+    Http::fake(function ($request) {
+        $url = (string) $request->url();
+
+        return match (true) {
+            str_contains($url, '/route/v1/driving/')   => Http::response(['code' => 'Ok', 'routes' => [['geometry' => '_p~iF~ps|U_ulLnnqC_mqNvxq`@', 'distance' => 42]]]),
+            str_contains($url, '/nearest/v1/driving/') => Http::response(['code' => 'Ok', 'waypoints' => [['name' => 'cached-road']]]),
+            str_contains($url, '/table/v1/driving/')   => Http::response(['code' => 'Ok', 'durations' => [[0, 5], [5, 0]]]),
+            str_contains($url, '/trip/v1/driving/')    => Http::response(['code' => 'Ok', 'trips' => [['distance' => 77]]]),
+            str_contains($url, '/match/v1/driving/')   => Http::response(['code' => 'Ok', 'matchings' => [['confidence' => 0.9]]]),
+            default                                    => Http::response(['code' => 'Unexpected'], 500),
+        };
+    });
+
+    // Mixed point representations convert through getPointFromMixed, and the
+    // successful route response decodes its polyline into waypoints
+    $mixedPoints = [
+        ['latitude' => 1.42, 'longitude' => 103.92],
+        new Point(1.43, 103.93),
+    ];
+    $route = OSRM::getRouteFromPoints($mixedPoints);
+    expect($route['routes'][0]['waypoints'])->not->toBeEmpty()
+        ->and($route['routes'][0]['distance'])->toBe(42);
+
+    // Second identical calls come straight from the cache
+    $point = new Point(1.30, 103.80);
+    $first = OSRM::getNearest($point, ['number' => 2]);
+    expect(OSRM::getNearest($point, ['number' => 2]))->toBe($first);
+
+    $table = OSRM::getTable($mixedPoints, ['annotations' => 'distance']);
+    expect(OSRM::getTable($mixedPoints, ['annotations' => 'distance']))->toBe($table);
+
+    $trip = OSRM::getTrip($mixedPoints, ['roundtrip' => 'true']);
+    expect(OSRM::getTrip($mixedPoints, ['roundtrip' => 'true']))->toBe($trip);
+
+    $match = OSRM::getMatch($mixedPoints, ['geometries' => 'polyline6']);
+    expect(OSRM::getMatch($mixedPoints, ['geometries' => 'polyline6'])['matchings'][0]['confidence'])->toBe(0.9);
+});

package/server/tests/SupportValueObjectsTest.php

@@ -0,0 +1,155 @@
+<?php
+
+namespace Fleetbase\Support {
+    if (!function_exists('Fleetbase\Support\url')) {
+        function url($path = ''): string
+        {
+            return 'https://api.test/' . ltrim((string) $path, '/');
+        }
+    }
+}
+
+namespace {
+    use Fleetbase\FleetOps\Casts\Point;
+    use Fleetbase\FleetOps\Contracts\TelematicProviderDescriptor;
+    use Fleetbase\FleetOps\Support\DistanceMatrix;
+    use Fleetbase\FleetOps\Support\Encoding\Polyline;
+    use Fleetbase\FleetOps\Support\FuelProviders\FuelProviderDescriptor;
+    use Fleetbase\FleetOps\Tracking\TrackingProviderCapabilities;
+
+    test('fuel provider descriptors apply defaults and serialize configured metadata', function () {
+        $descriptor = new FuelProviderDescriptor([
+            'key'                => 'fleet_card',
+            'description'        => 'Fleet card transactions.',
+            'required_fields'    => [['name' => 'api_key']],
+            'capabilities'       => ['vehicles', 'transactions'],
+            'sync_defaults'      => ['window_days' => 14],
+            'setup_instructions' => ['Connect the account.'],
+            'metadata'           => ['region' => 'mena'],
+        ]);
+
+        expect($descriptor->label)->toBe('fleet_card')
+            ->and($descriptor->type)->toBe('native')
+            ->and($descriptor->driverClass)->toBeNull()
+            ->and($descriptor->docsUrl)->toBeNull()
+            ->and($descriptor->category)->toBeNull()
+            ->and($descriptor->icon)->toBe('gas-pump')
+            ->and($descriptor->toArray())->toMatchArray([
+                'key'                => 'fleet_card',
+                'label'              => 'fleet_card',
+                'type'               => 'native',
+                'description'        => 'Fleet card transactions.',
+                'required_fields'    => [['name' => 'api_key']],
+                'capabilities'       => ['vehicles', 'transactions'],
+                'sync_defaults'      => ['window_days' => 14],
+                'setup_instructions' => ['Connect the account.'],
+                'metadata'           => ['region' => 'mena'],
+            ]);
+    });
+
+    test('telematic provider descriptors include defaults and webhook metadata', function () {
+        $previousApp = Illuminate\Container\Container::getInstance();
+        Illuminate\Container\Container::setInstance(new class extends Illuminate\Container\Container {
+            public function environment(...$environments)
+            {
+                return false;
+            }
+        });
+
+        $descriptor = new TelematicProviderDescriptor([
+            'key'                => 'safee',
+            'label'              => 'Safee',
+            'driver_class'       => TestTelematicDriver::class,
+            'required_fields'    => [['name' => 'token']],
+            'supports_webhooks'  => true,
+            'supports_discovery' => true,
+            'metadata'           => ['region' => 'global'],
+        ]);
+
+        try {
+            $array = $descriptor->toArray();
+
+            expect($descriptor->type)->toBe('native')
+                ->and($descriptor->icon)->toBe(TelematicProviderDescriptor::DEFAULT_ICON)
+                ->and($array)->toMatchArray([
+                    'key'                => 'safee',
+                    'label'              => 'Safee',
+                    'type'               => 'native',
+                    'required_fields'    => [['name' => 'token']],
+                    'supports_webhooks'  => true,
+                    'supports_discovery' => true,
+                    'metadata'           => ['region' => 'global'],
+                ])
+                ->and($array['webhook_url'])->toContain('webhooks/telematics/safee')
+                ->and(json_decode($descriptor->toJson(), true))->toMatchArray($array);
+        } finally {
+            Illuminate\Container\Container::setInstance($previousApp);
+        }
+    });
+
+    test('tracking provider capabilities merge standard and provider-specific capabilities', function () {
+        $capabilities = new TrackingProviderCapabilities(
+            traffic: true,
+            perLegEta: true,
+            mapMatching: false,
+            routeGeometry: true,
+            extras: ['snap_to_road' => true],
+        );
+
+        expect($capabilities->toArray())->toBe([
+            'traffic'        => true,
+            'per_leg_eta'    => true,
+            'map_matching'   => false,
+            'route_geometry' => true,
+            'snap_to_road'   => true,
+        ])->and($capabilities->jsonSerialize())->toBe($capabilities->toArray());
+    });
+
+    test('distance matrix serializes nullable distance and time values', function () {
+        $matrix = new DistanceMatrix(1234.5, null);
+
+        expect($matrix->distance)->toBe(1234.5)
+            ->and($matrix->time)->toBeNull()
+            ->and($matrix->jsonSerialize())->toBe([
+                'distance' => 1234.5,
+                'time'     => null,
+            ])
+            ->and(json_encode($matrix))->toBe('{"distance":1234.5,"time":null}');
+    });
+
+    test('point cast helpers normalize coordinate geometry and raw binary detection', function () {
+        expect(Point::coordinatesBboxToFloat([
+            'type'        => 'Point',
+            'coordinates' => ['106.917', '47.918'],
+            'bbox'        => ['106', '47', '107', '48'],
+        ]))->toBe([
+            'type'        => 'Point',
+            'coordinates' => [106.917, 47.918],
+            'bbox'        => [106.0, 47.0, 107.0, 48.0],
+        ])
+            ->and(Point::isRawPoint("abc\x00def"))->toBeTrue()
+            ->and(Point::isRawPoint('plain text'))->toBeFalse()
+            ->and(Point::isRawPoint(['not' => 'a string']))->toBeFalse()
+            ->and(Point::hex2str('48656c6c6f'))->toBe('Hello');
+    });
+
+    test('polyline encoding round trips flattened and paired coordinate lists', function () {
+        $points  = [[38.5, -120.2], [40.7, -120.95], [43.252, -126.453]];
+        $encoded = Polyline::encode($points);
+        $decoded = Polyline::decode($encoded);
+
+        expect($encoded)->toBe('_p~iF~ps|U_ulLnnqC_mqNvxq`@')
+            ->and(Polyline::flatten($points))->toBe([38.5, -120.2, 40.7, -120.95, 43.252, -126.453])
+            ->and($decoded)->toHaveCount(3)
+            ->and($decoded[0]->getLng())->toBe(38.5)
+            ->and($decoded[0]->getLat())->toBe(-120.2)
+            ->and($decoded[2]->getLng())->toBe(43.252)
+            ->and($decoded[2]->getLat())->toBe(-126.453)
+            ->and(Polyline::pair([1, 2, 3, 4]))->toBe([[1, 2], [3, 4]])
+            ->and(Polyline::pair('not a list'))->toBe([]);
+    });
+
+    class TestTelematicDriver
+    {
+    }
+}

package/server/tests/TelematicControllerContractsTest.php

@@ -0,0 +1,185 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\CustomerController;
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\TelematicController;
+use Fleetbase\FleetOps\Models\Contact;
+use Fleetbase\FleetOps\Models\Telematic;
+use Fleetbase\FleetOps\Support\Telematics\TelematicProviderRegistry;
+use Fleetbase\FleetOps\Support\Telematics\TelematicService;
+use Fleetbase\Models\Activity;
+
+class FleetOpsTelematicControllerProbe extends TelematicController
+{
+    public function __construct()
+    {
+        parent::__construct(new TelematicService(new TelematicProviderRegistry()), new TelematicProviderRegistry());
+    }
+
+    public function callHelper(string $method, mixed ...$arguments): mixed
+    {
+        $reflection = new ReflectionMethod(TelematicController::class, $method);
+        $reflection->setAccessible(true);
+
+        return $reflection->invoke($this, ...$arguments);
+    }
+}
+
+class FleetOpsCustomerControllerProbe extends CustomerController
+{
+    public function callHelper(string $method, mixed ...$arguments): mixed
+    {
+        $reflection = new ReflectionMethod(CustomerController::class, $method);
+        $reflection->setAccessible(true);
+
+        return $reflection->invoke($this, ...$arguments);
+    }
+}
+
+class FleetOpsActivityLogFake extends Activity
+{
+    public array $fakeAttributes = [];
+
+    public function getAttribute($key)
+    {
+        if (array_key_exists($key, $this->fakeAttributes)) {
+            return $this->fakeAttributes[$key];
+        }
+
+        return parent::getAttribute($key);
+    }
+}
+
+test('internal telematic controller builds metadata log entries for sync and connection states', function () {
+    $controller = new FleetOpsTelematicControllerProbe();
+    $telematic  = new Telematic();
+    $telematic->setRawAttributes([
+        'uuid' => 'telematic-uuid',
+        'meta' => [
+            'last_sync_result'       => 'failed',
+            'last_sync_job_id'       => 'sync-job-1',
+            'last_sync_total'        => 7,
+            'last_sync_error'        => 'SQLSTATE connection: token leaked',
+            'last_sync_error_type'   => 'database',
+            'last_sync_started_at'   => '2026-01-01 09:00:00',
+            'last_sync_failed_at'    => '2026-01-01 09:05:00',
+            'last_test_result'       => 'success',
+            'last_connection_test'   => '2026-01-01 10:00:00',
+        ],
+    ], true);
+
+    $logs = $controller->callHelper('makeTelematicMetadataLogs', $telematic);
+
+    expect($logs)->toHaveCount(2)
+        ->and($logs[0])->toMatchArray([
+            'id'          => 'sync-sync-job-1',
+            'type'        => 'sync_failed',
+            'label'       => 'Device sync failed',
+            'description' => 'Device sync failed. Review the provider connection and server logs, then try again.',
+            'status'      => 'warning',
+            'icon'        => 'circle-exclamation',
+            'created_at'  => '2026-01-01 09:05:00',
+            'actor_name'  => null,
+            'metadata'    => [
+                'job_id'       => 'sync-job-1',
+                'result'       => 'failed',
+                'total'        => 7,
+                'error_type'   => 'database',
+                'started_at'   => '2026-01-01 09:00:00',
+                'completed_at' => null,
+                'failed_at'    => '2026-01-01 09:05:00',
+            ],
+        ])
+        ->and($logs[1])->toMatchArray([
+            'id'          => 'connection-test-2026-01-01 10:00:00',
+            'type'        => 'connection_test_success',
+            'label'       => 'Connection test verified',
+            'description' => 'Provider credentials were verified successfully.',
+            'status'      => 'success',
+            'icon'        => 'plug',
+            'created_at'  => '2026-01-01 10:00:00',
+        ]);
+});
+
+test('internal telematic controller describes activity logs and safe issue messages', function () {
+    $controller = new FleetOpsTelematicControllerProbe();
+
+    $created                 = new FleetOpsActivityLogFake();
+    $created->fakeAttributes = [
+        'uuid'       => 'activity-created',
+        'event'      => 'created',
+        'created_at' => '2026-01-01 11:00:00',
+    ];
+    $created->setRelation('causer', (object) ['name' => 'Ada Admin']);
+
+    $deleted                 = new FleetOpsActivityLogFake();
+    $deleted->fakeAttributes = [
+        'uuid'       => null,
+        'id'         => 99,
+        'event'      => 'deleted',
+        'created_at' => '2026-01-01 12:00:00',
+        'causer'     => null,
+    ];
+
+    expect($controller->callHelper('makeActivityLogEntry', $created))->toMatchArray([
+        'id'          => 'activity-created',
+        'type'        => 'activity_created',
+        'label'       => 'Provider connection created',
+        'description' => 'Provider connection details were created.',
+        'status'      => 'default',
+        'icon'        => 'plus',
+        'created_at'  => '2026-01-01 11:00:00',
+        'actor_name'  => 'Ada Admin',
+        'metadata'    => ['event' => 'created'],
+    ])
+        ->and($controller->callHelper('makeActivityLogEntry', $deleted))->toMatchArray([
+            'id'          => 99,
+            'type'        => 'activity_deleted',
+            'label'       => 'Provider connection deleted',
+            'description' => 'Provider connection details were removed.',
+            'status'      => 'warning',
+            'icon'        => 'history',
+            'metadata'    => ['event' => 'deleted'],
+        ])
+        ->and($controller->callHelper('syncSuccessDescription', ['last_sync_total' => 3]))->toBe('3 provider devices were synced.')
+        ->and($controller->callHelper('syncSuccessDescription', []))->toBe('Provider device sync completed successfully.')
+        ->and($controller->callHelper('userFacingIssueMessage', 'Provider timed out', 'fallback'))->toBe('Provider timed out')
+        ->and($controller->callHelper('userFacingIssueMessage', 'select * from users', 'fallback'))->toBe('fallback')
+        ->and($controller->callHelper('isSensitiveIssueMessage', 'stack trace leaked'))->toBeTrue()
+        ->and($controller->callHelper('isSensitiveIssueMessage', 'Provider rejected credentials'))->toBeFalse();
+});
+
+test('internal customer controller serializes portal login payloads', function () {
+    $controller = new FleetOpsCustomerControllerProbe();
+    $customer   = new Contact();
+    $customer->setRawAttributes([
+        'uuid'      => 'customer-uuid',
+        'public_id' => 'customer-public',
+        'user_uuid' => 'user-uuid',
+    ], true);
+    $customer->setRelation('user', (object) [
+        'uuid'           => 'user-uuid',
+        'public_id'      => 'user-public',
+        'name'           => 'Ada Customer',
+        'email'          => 'ada@example.test',
+        'phone'          => '+15551234567',
+        'status'         => 'active',
+        'session_status' => 'online',
+        'avatar_url'     => 'https://example.test/avatar.png',
+    ]);
+
+    expect($controller->callHelper('customerPayload', $customer))->toBe([
+        'id'        => 'customer-public',
+        'uuid'      => 'customer-uuid',
+        'user_uuid' => 'user-uuid',
+        'user'      => [
+            'id'             => 'user-public',
+            'uuid'           => 'user-uuid',
+            'name'           => 'Ada Customer',
+            'email'          => 'ada@example.test',
+            'phone'          => '+15551234567',
+            'status'         => 'active',
+            'session_status' => 'online',
+            'avatar_url'     => 'https://example.test/avatar.png',
+        ],
+    ]);
+});