@fleetbase/fleetops-engine 0.6.58 → 0.6.59

package/server/tests/SamsaraProviderContractsTest.php

@@ -0,0 +1,272 @@
+<?php
+
+use Fleetbase\FleetOps\Support\Telematics\Providers\SamsaraProvider;
+use Illuminate\Support\Carbon;
+
+class FleetOpsSamsaraProviderProbe extends SamsaraProvider
+{
+    public array $requests        = [];
+    public array $queuedResponses = [];
+    public ?Throwable $failure    = null;
+
+    public function authenticateForTest(array $credentials): array
+    {
+        $this->credentials = $credentials;
+        $this->prepareAuthentication();
+
+        return $this->headers;
+    }
+
+    protected function request(string $method, string $endpoint, array $data = []): array
+    {
+        $this->requests[] = [$method, $endpoint, $data];
+
+        if ($this->failure) {
+            throw $this->failure;
+        }
+
+        return array_shift($this->queuedResponses) ?? [];
+    }
+}
+
+test('samsara provider authenticates and reports connection metadata', function () {
+    $provider                  = new FleetOpsSamsaraProviderProbe();
+    $provider->queuedResponses = [
+        ['data' => [['id' => 'user-1'], ['id' => 'user-2']]],
+    ];
+
+    expect($provider->authenticateForTest(['api_token' => 'token-123']))->toBe([
+        'Authorization' => 'Bearer token-123',
+        'Accept'        => 'application/json',
+    ]);
+
+    $result = $provider->testConnection(['api_token' => 'token-456']);
+
+    expect($result)->toBe([
+        'success'  => true,
+        'message'  => 'Connection successful',
+        'metadata' => ['users_count' => 2],
+    ])
+        ->and($provider->requests)->toBe([
+            ['GET', '/fleet/users', []],
+        ]);
+
+    $failing          = new FleetOpsSamsaraProviderProbe();
+    $failing->failure = new RuntimeException('forbidden');
+
+    expect($failing->testConnection(['api_token' => 'bad']))->toBe([
+        'success'  => false,
+        'message'  => 'forbidden',
+        'metadata' => [],
+    ]);
+});
+
+test('samsara provider fetches devices with cursor pagination and details', function () {
+    $provider                  = new FleetOpsSamsaraProviderProbe();
+    $provider->queuedResponses = [
+        [
+            'data'       => [['id' => 'veh-1'], ['id' => 'veh-2']],
+            'pagination' => ['hasNextPage' => true, 'endCursor' => 'cursor-2'],
+        ],
+        [
+            'data'       => [['id' => 'veh-3']],
+            'pagination' => ['hasNextPage' => false, 'endCursor' => 'cursor-3'],
+        ],
+        ['data' => ['id' => 'veh-99', 'name' => 'Vehicle 99']],
+    ];
+
+    expect($provider->fetchDevices(['limit' => 2]))->toBe([
+        'devices'     => [['id' => 'veh-1'], ['id' => 'veh-2']],
+        'next_cursor' => 'cursor-2',
+        'has_more'    => true,
+    ])
+        ->and($provider->fetchDevices(['limit' => 2, 'cursor' => 'cursor-2']))->toBe([
+            'devices'     => [['id' => 'veh-3']],
+            'next_cursor' => null,
+            'has_more'    => false,
+        ])
+        ->and($provider->fetchDeviceDetails('veh-99'))->toBe(['id' => 'veh-99', 'name' => 'Vehicle 99'])
+        ->and($provider->requests)->toBe([
+            ['GET', '/fleet/vehicles', ['limit' => 2]],
+            ['GET', '/fleet/vehicles', ['limit' => 2, 'after' => 'cursor-2']],
+            ['GET', '/fleet/vehicles/veh-99', []],
+        ]);
+});
+
+test('samsara provider normalizes devices events and sensors from payload variants', function () {
+    Carbon::setTestNow(Carbon::parse('2026-07-26 12:00:00', 'UTC'));
+
+    try {
+        $provider = new SamsaraProvider();
+        $device   = $provider->normalizeDevice([
+            'id'            => 'veh-1',
+            'name'          => 'Truck One',
+            'make'          => 'Volvo',
+            'vin'           => 'VIN-1',
+            'serialNumber'  => 'SERIAL-1',
+            'licensePlate'  => 'ABC-123',
+            'status'        => 'offline',
+            'isOnline'      => 'false',
+            'location'      => [
+                'time'              => '2026-07-26T10:00:00Z',
+                'latitude'          => 1.25,
+                'longitude'         => 103.75,
+                'speedMilesPerHour' => 45,
+                'headingDegrees'    => 180,
+                'altitudeMeters'    => 12,
+            ],
+            'odometerMeters' => 1200,
+            'fuelPercent'    => ['value' => 73],
+        ]);
+        $fallback = $provider->normalizeDevice([
+            'id'                => 'veh-2',
+            'gps'               => [
+                'time'              => '2026-07-26T11:30:00Z',
+                'lat'               => 2.5,
+                'lng'               => 104.5,
+                'speedMilesPerHour' => 12,
+                'headingDegrees'    => 90,
+                'altitudeMeters'    => 5,
+            ],
+            'gateway'           => ['status' => 'connected', 'online' => true],
+            'obdOdometerMeters' => ['value' => 450],
+            'fuelPercent'       => 50,
+        ]);
+        $event = $provider->normalizeEvent([
+            'id'              => 'event-1',
+            'vehicle'         => ['id' => 'veh-1'],
+            'eventType'       => 'harsh_brake',
+            'time'            => '2026-07-26T09:00:00Z',
+            'currentLocation' => [
+                'latitude'  => 1.3,
+                'longitude' => 103.8,
+            ],
+            'speed'          => 20,
+            'headingDegrees' => 45,
+            'altitudeMeters' => 7,
+            'online'         => 'yes',
+        ]);
+        $sensor = $provider->normalizeSensor([
+            'sensorType' => 'temperature',
+            'value'      => 21.5,
+            'unit'       => 'c',
+            'time'       => '2026-07-26T08:00:00Z',
+        ]);
+
+        expect($device)->toMatchArray([
+            'device_id'     => 'veh-1',
+            'external_id'   => 'veh-1',
+            'name'          => 'Truck One',
+            'provider'      => 'samsara',
+            'model'         => 'Volvo',
+            'vin'           => 'VIN-1',
+            'serial_number' => 'SERIAL-1',
+            'license_plate' => 'ABC-123',
+            'status'        => 'inactive',
+            'online'        => false,
+            'last_seen_at'  => '2026-07-26 10:00:00',
+            'location'      => ['lat' => 1.25, 'lng' => 103.75],
+            'speed'         => 45,
+            'heading'       => 180,
+            'altitude'      => 12,
+            'odometer'      => 1200,
+            'fuel_level'    => 73,
+        ])
+            ->and($device['meta']['provider_status'])->toBe([
+                'status' => 'offline',
+                'online' => 'false',
+            ])
+            ->and($fallback)->toMatchArray([
+                'device_id'    => 'veh-2',
+                'name'         => 'Unknown Device',
+                'status'       => 'active',
+                'online'       => true,
+                'last_seen_at' => '2026-07-26 11:30:00',
+                'location'     => ['lat' => 2.5, 'lng' => 104.5],
+                'speed'        => 12,
+                'heading'      => 90,
+                'altitude'     => 5,
+                'odometer'     => 450,
+                'fuel_level'   => 50,
+            ])
+            ->and($event)->toMatchArray([
+                'external_id' => 'event-1',
+                'device_id'   => 'veh-1',
+                'event_type'  => 'harsh_brake',
+                'occurred_at' => '2026-07-26 09:00:00',
+                'online'      => true,
+                'location'    => ['lat' => 1.3, 'lng' => 103.8],
+                'speed'       => 20,
+                'heading'     => 45,
+                'altitude'    => 7,
+            ])
+            ->and($sensor)->toMatchArray([
+                'sensor_type' => 'temperature',
+                'value'       => 21.5,
+                'unit'        => 'c',
+                'recorded_at' => '2026-07-26T08:00:00Z',
+            ]);
+    } finally {
+        Carbon::setTestNow();
+    }
+});
+
+test('samsara provider validates webhooks and normalizes webhook batches', function () {
+    Carbon::setTestNow(Carbon::parse('2026-07-26 12:00:00', 'UTC'));
+
+    try {
+        $provider  = new SamsaraProvider();
+        $payload   = 'raw-body';
+        $signature = hash_hmac('sha256', $payload, 'secret');
+        $processed = $provider->processWebhook([
+            'data' => [
+                [
+                    'id'      => 'event-1',
+                    'time'    => '2026-07-26T10:00:00Z',
+                    'vehicle' => [
+                        'id'       => 'veh-1',
+                        'name'     => 'Truck One',
+                        'location' => [
+                            'latitude'  => 1.25,
+                            'longitude' => 103.75,
+                        ],
+                    ],
+                ],
+                [
+                    'id'        => 'event-2',
+                    'vehicleId' => 'veh-2',
+                ],
+            ],
+        ]);
+
+        expect($provider->validateWebhookSignature($payload, 'anything', []))->toBeTrue()
+            ->and($provider->validateWebhookSignature($payload, $signature, ['webhook_secret' => 'secret']))->toBeTrue()
+            ->and($provider->validateWebhookSignature($payload, 'wrong', ['webhook_secret' => 'secret']))->toBeFalse()
+            ->and($processed['devices'])->toHaveCount(1)
+            ->and($processed['devices'][0]['device_id'])->toBe('veh-1')
+            ->and($processed['events'])->toHaveCount(2)
+            ->and($processed['events'][0]['device_id'])->toBe('veh-1')
+            ->and($processed['events'][1]['device_id'])->toBe('veh-2')
+            ->and($processed['sensors'])->toBe([]);
+    } finally {
+        Carbon::setTestNow();
+    }
+});
+
+test('samsara provider exposes credential schema webhook support and rate limits', function () {
+    $provider = new SamsaraProvider();
+    $schema   = $provider->getCredentialSchema();
+
+    expect($provider->supportsWebhooks())->toBeTrue()
+        ->and($provider->supportsDiscovery())->toBeTrue()
+        ->and($provider->getRateLimits())->toBe([
+            'requests_per_minute' => 60,
+            'burst_size'          => 10,
+        ])
+        ->and($schema)->toHaveCount(2)
+        ->and($schema[0]['name'])->toBe('api_token')
+        ->and($schema[0]['required'])->toBeTrue()
+        ->and($schema[0]['validation'])->toBe('required|string|min:20')
+        ->and($schema[1]['name'])->toBe('webhook_secret')
+        ->and($schema[1]['required'])->toBeFalse();
+});

package/server/tests/SearchControllerContractsTest.php

@@ -0,0 +1,311 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\SearchController;
+use Fleetbase\FleetOps\Models\Contact;
+use Fleetbase\FleetOps\Models\Device;
+use Fleetbase\FleetOps\Models\DeviceEvent;
+use Fleetbase\FleetOps\Models\Equipment;
+use Fleetbase\FleetOps\Models\Fleet;
+use Fleetbase\FleetOps\Models\FuelProviderConnection;
+use Fleetbase\FleetOps\Models\FuelProviderTransaction;
+use Fleetbase\FleetOps\Models\FuelReport;
+use Fleetbase\FleetOps\Models\Issue;
+use Fleetbase\FleetOps\Models\Maintenance;
+use Fleetbase\FleetOps\Models\MaintenanceSchedule;
+use Fleetbase\FleetOps\Models\OrderConfig;
+use Fleetbase\FleetOps\Models\Part;
+use Fleetbase\FleetOps\Models\Place;
+use Fleetbase\FleetOps\Models\Sensor;
+use Fleetbase\FleetOps\Models\ServiceRate;
+use Fleetbase\FleetOps\Models\Telematic;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Models\Vendor;
+use Fleetbase\FleetOps\Models\WorkOrder;
+use Illuminate\Http\Request;
+use Illuminate\Support\Collection;
+
+function fleetopsSearchControllerMethod(string $method): ReflectionMethod
+{
+    $reflection = new ReflectionMethod(SearchController::class, $method);
+    $reflection->setAccessible(true);
+
+    return $reflection;
+}
+
+class FleetOpsSearchGenericProbe extends SearchController
+{
+    public array $calls         = [];
+    public array $modelsByClass = [];
+
+    protected function searchGeneric(string $modelClass, array $columns, string $query, int $limit, callable $mapper): Collection
+    {
+        $this->calls[] = [$modelClass, $columns, $query, $limit];
+        $model         = $this->modelsByClass[$modelClass] ?? fleetopsSearchModel($modelClass);
+
+        return collect([$mapper($model)]);
+    }
+}
+
+function fleetopsSearchModel(string $modelClass)
+{
+    $model = new $modelClass();
+    $model->setRawAttributes([
+        'uuid'                    => 'model-uuid',
+        'public_id'               => 'model_public',
+        'name'                    => 'Model Name',
+        'description'             => 'Description',
+        'email'                   => 'ops@example.test',
+        'phone'                   => '+15555550123',
+        'business_id'             => 'business-id',
+        'street1'                 => '1 Main St',
+        'city'                    => 'Singapore',
+        'country'                 => 'Singapore',
+        'issue_id'                => 'issue-id',
+        'category'                => 'safety',
+        'type'                    => 'inspection',
+        'report'                  => 'Fuel report text',
+        'title'                   => 'Flat tire',
+        'priority'                => 'high',
+        'status'                  => 'open',
+        'currency'                => 'SGD',
+        'provider'                => 'provider',
+        'provider_transaction_id' => 'txn-123',
+        'station_name'            => 'Fuel Station',
+        'sync_status'             => 'synced',
+        'code'                    => 'WO-1',
+        'subject'                 => 'Brake check',
+        'instructions'            => 'Inspect brakes',
+        'summary'                 => 'Maintenance summary',
+        'notes'                   => 'Maintenance notes',
+        'manufacturer'            => 'Acme',
+        'model'                   => 'MX',
+        'serial_number'           => 'SN-1',
+        'sku'                     => 'SKU-1',
+        'barcode'                 => 'BAR-1',
+        'environment'             => 'sandbox',
+        'imei'                    => 'IMEI-1',
+        'device_id'               => 'device-1',
+        'internal_id'             => 'internal-1',
+        'unit'                    => 'c',
+        'event_type'              => 'ignition',
+        'message'                 => 'Engine on',
+        'ident'                   => 'ident-1',
+        'severity'                => 'info',
+        'service_name'            => 'Same Day',
+        'service_type'            => 'delivery',
+        'rate_calculation_method' => 'distance',
+        'key'                     => 'transport',
+        'namespace'               => 'fleet-ops',
+        'make'                    => 'Toyota',
+        'year'                    => '2025',
+        'plate_number'            => 'SG-1234',
+        'vin'                     => 'VIN123',
+    ], true);
+
+    return $model;
+}
+
+test('search controller returns an empty result set for blank queries', function () {
+    $controller = new SearchController();
+
+    $response = $controller->search(new Request(['query' => '   ']));
+
+    expect($response->getStatusCode())->toBe(200)
+        ->and($response->getData(true))->toBe(['results' => []]);
+});
+
+test('search controller normalizes requested types from strings arrays and invalid values', function () {
+    $controller     = new SearchController();
+    $requestedTypes = fleetopsSearchControllerMethod('requestedTypes');
+
+    expect($requestedTypes->invoke($controller, new Request(['types' => 'orders, drivers,invalid, vehicles'])))->toBe(['orders', 'drivers', 'vehicles'])
+        ->and($requestedTypes->invoke($controller, new Request(['types' => ['places', 'not-real', 'devices']])))->toBe(['places', 'devices'])
+        ->and($requestedTypes->invoke($controller, new Request(['types' => ['not-real']])))->toContain('orders', 'drivers', 'vehicles', 'order_configs')
+        ->and($requestedTypes->invoke($controller, new Request(['types' => new stdClass()])))->toContain('orders', 'drivers', 'vehicles', 'order_configs');
+});
+
+test('search controller falls back to an empty collection for unknown search types', function () {
+    $controller = new SearchController();
+    $searchType = fleetopsSearchControllerMethod('searchType');
+
+    $result = $searchType->invoke($controller, 'unknown', 'needle', 5);
+
+    expect($result)->toBeInstanceOf(Collection::class)
+        ->and($result->all())->toBe([]);
+});
+
+test('search controller route model and description helpers normalize display values', function () {
+    $controller  = new SearchController();
+    $routeModel  = fleetopsSearchControllerMethod('routeModel');
+    $description = fleetopsSearchControllerMethod('description');
+
+    expect($routeModel->invoke($controller, (object) ['public_id' => 'public-id', 'uuid' => 'uuid']))->toBe('public-id')
+        ->and($routeModel->invoke($controller, (object) ['public_id' => null, 'uuid' => 'uuid']))->toBe('uuid')
+        ->and($description->invoke($controller, ' active ', null, ['ignored'], 42, false))->toBe('active  42');
+});
+
+test('search controller generic resource mappers return console navigation results', function (string $method, string $modelClass, array $expected) {
+    $controller = new FleetOpsSearchGenericProbe();
+    $search     = fleetopsSearchControllerMethod($method);
+
+    $result = $search->invoke($controller, 'needle', 3)->first();
+
+    expect($result)->toMatchArray($expected)
+        ->and($result['models'] ?? null)->toBe(['model_public'])
+        ->and($controller->calls[0][0])->toBe($modelClass)
+        ->and($controller->calls[0][2])->toBe('needle')
+        ->and($controller->calls[0][3])->toBe(3);
+})->with([
+    'vehicles' => ['searchVehicles', Vehicle::class, [
+        'label'      => 'Model Name',
+        'icon'       => 'truck',
+        'type'       => 'Vehicle',
+        'route'      => 'console.fleet-ops.management.vehicles.index.details',
+        'breadcrumb' => 'Fleet-Ops > Resources > Vehicles',
+    ]],
+    'fleets' => ['searchFleets', Fleet::class, [
+        'label'      => 'Model Name',
+        'icon'       => 'user-group',
+        'type'       => 'Fleet',
+        'route'      => 'console.fleet-ops.management.fleets.index.details',
+        'breadcrumb' => 'Fleet-Ops > Resources > Fleets',
+    ]],
+    'vendors' => ['searchVendors', Vendor::class, [
+        'label'      => 'Model Name',
+        'icon'       => 'warehouse',
+        'type'       => 'Vendor',
+        'route'      => 'console.fleet-ops.management.vendors.index.details',
+        'breadcrumb' => 'Fleet-Ops > Resources > Vendors',
+    ]],
+    'contacts' => ['searchContacts', Contact::class, [
+        'label'      => 'Model Name',
+        'icon'       => 'address-book',
+        'type'       => 'Contact',
+        'route'      => 'console.fleet-ops.management.contacts.index.details',
+        'breadcrumb' => 'Fleet-Ops > Resources > Contacts',
+    ]],
+    'places' => ['searchPlaces', Place::class, [
+        'label'      => 'Model Name',
+        'icon'       => 'location-dot',
+        'type'       => 'Place',
+        'route'      => 'console.fleet-ops.management.places.index.details',
+        'breadcrumb' => 'Fleet-Ops > Resources > Places',
+    ]],
+    'issues' => ['searchIssues', Issue::class, [
+        'label'      => 'Flat tire',
+        'icon'       => 'triangle-exclamation',
+        'type'       => 'Issue',
+        'route'      => 'console.fleet-ops.management.issues.index.details',
+        'breadcrumb' => 'Fleet-Ops > Resources > Issues',
+    ]],
+    'fuel reports' => ['searchFuelReports', FuelReport::class, [
+        'label'      => 'model_public',
+        'icon'       => 'gas-pump',
+        'type'       => 'Fuel Report',
+        'route'      => 'console.fleet-ops.management.fuel-reports.index.details',
+        'breadcrumb' => 'Fleet-Ops > Resources > Fuel Reports',
+    ]],
+    'fuel transactions' => ['searchFuelTransactions', FuelProviderTransaction::class, [
+        'label'      => 'model_public',
+        'icon'       => 'credit-card',
+        'type'       => 'Fuel Transaction',
+        'route'      => 'console.fleet-ops.management.fuel-transactions.index.details',
+        'breadcrumb' => 'Fleet-Ops > Resources > Fuel Transactions',
+    ]],
+    'maintenance schedules' => ['searchMaintenanceSchedules', MaintenanceSchedule::class, [
+        'label'      => 'Model Name',
+        'icon'       => 'calendar-alt',
+        'type'       => 'Maintenance Schedule',
+        'route'      => 'console.fleet-ops.maintenance.schedules.index.details',
+        'breadcrumb' => 'Fleet-Ops > Maintenance > Schedules',
+    ]],
+    'work orders' => ['searchWorkOrders', WorkOrder::class, [
+        'label'      => 'WO-1',
+        'icon'       => 'clipboard-list',
+        'type'       => 'Work Order',
+        'route'      => 'console.fleet-ops.maintenance.work-orders.index.details',
+        'breadcrumb' => 'Fleet-Ops > Maintenance > Work Orders',
+    ]],
+    'maintenances' => ['searchMaintenances', Maintenance::class, [
+        'label'      => 'Maintenance summary',
+        'icon'       => 'history',
+        'type'       => 'Maintenance',
+        'route'      => 'console.fleet-ops.maintenance.maintenances.index.details',
+        'breadcrumb' => 'Fleet-Ops > Maintenance > Maintenances',
+    ]],
+    'equipment' => ['searchEquipment', Equipment::class, [
+        'label'      => 'Model Name',
+        'icon'       => 'trailer',
+        'type'       => 'Equipment',
+        'route'      => 'console.fleet-ops.maintenance.equipment.index.details',
+        'breadcrumb' => 'Fleet-Ops > Maintenance > Equipment',
+    ]],
+    'parts' => ['searchParts', Part::class, [
+        'label'      => 'Model Name',
+        'icon'       => 'cog',
+        'type'       => 'Part',
+        'route'      => 'console.fleet-ops.maintenance.parts.index.details',
+        'breadcrumb' => 'Fleet-Ops > Maintenance > Parts',
+    ]],
+    'fuel providers' => ['searchFuelProviders', FuelProviderConnection::class, [
+        'label'      => 'Model Name',
+        'icon'       => 'gas-pump',
+        'type'       => 'Fuel Integration',
+        'route'      => 'console.fleet-ops.connectivity.fuel-providers.details',
+        'breadcrumb' => 'Fleet-Ops > Connectivity > Fuel Integrations',
+    ]],
+    'telematics' => ['searchTelematics', Telematic::class, [
+        'label'      => 'Model Name',
+        'icon'       => 'satellite-dish',
+        'type'       => 'Telematic Provider',
+        'route'      => 'console.fleet-ops.connectivity.telematics.details',
+        'breadcrumb' => 'Fleet-Ops > Connectivity > Telematics',
+    ]],
+    'devices' => ['searchDevices', Device::class, [
+        'label'      => 'Model Name',
+        'icon'       => 'hard-drive',
+        'type'       => 'Device',
+        'route'      => 'console.fleet-ops.connectivity.devices.index.details',
+        'breadcrumb' => 'Fleet-Ops > Connectivity > Devices',
+    ]],
+    'sensors' => ['searchSensors', Sensor::class, [
+        'label'      => 'Model Name',
+        'icon'       => 'temperature-full',
+        'type'       => 'Sensor',
+        'route'      => 'console.fleet-ops.connectivity.sensors.index.details',
+        'breadcrumb' => 'Fleet-Ops > Connectivity > Sensors',
+    ]],
+    'events' => ['searchEvents', DeviceEvent::class, [
+        'label'      => 'ignition',
+        'icon'       => 'stream',
+        'type'       => 'Device Event',
+        'route'      => 'console.fleet-ops.connectivity.events.details',
+        'breadcrumb' => 'Fleet-Ops > Connectivity > Events',
+    ]],
+    'service rates' => ['searchServiceRates', ServiceRate::class, [
+        'label'      => 'Same Day',
+        'icon'       => 'file-invoice-dollar',
+        'type'       => 'Service Rate',
+        'route'      => 'console.fleet-ops.operations.service-rates.index.details',
+        'breadcrumb' => 'Fleet-Ops > Operations > Service Rates',
+    ]],
+]);
+
+test('search controller order config mapper returns query params instead of model identifiers', function () {
+    $controller = new FleetOpsSearchGenericProbe();
+    $search     = fleetopsSearchControllerMethod('searchOrderConfigs');
+
+    $result = $search->invoke($controller, 'needle', 4)->first();
+
+    expect($result)->toMatchArray([
+        'label'       => 'Model Name',
+        'icon'        => 'diagram-project',
+        'type'        => 'Order Config',
+        'route'       => 'console.fleet-ops.operations.order-config',
+        'queryParams' => ['query' => 'needle'],
+        'breadcrumb'  => 'Fleet-Ops > Operations > Order Config',
+    ])
+        ->and($result)->not->toHaveKey('models')
+        ->and($controller->calls[0][0])->toBe(OrderConfig::class)
+        ->and($controller->calls[0][3])->toBe(4);
+});

package/server/tests/ServiceRateRouteValidationTest.php

@@ -99,3 +99,79 @@ test('service rates for route ignores placeholder service type values', function
     'null'      => ['null'],
     'empty'     => [''],
 ]);
+
+test('service rates route filters real service types normalizes values and exports', function () {
+    // Real service types apply the service_type filter inside the callback
+    $controller = fleetopsServiceRateRouteController();
+    $controller->getServicesForRoute(fleetopsServiceRateRouteRequest([
+        'coordinates'  => '1.3621663,103.8845049;1.353151,103.86458',
+        'service_type' => 'ftl',
+    ]));
+    $query = new class {
+        public array $wheres = [];
+
+        public function where($column, $value)
+        {
+            $this->wheres[] = [$column, $value];
+
+            return $this;
+        }
+    };
+    ($controller->queryCallback)($query);
+    expect($query->wheres)->toContain(['service_type', 'ftl']);
+
+    // Non-string optional values normalize to null
+    $reflection = new ReflectionMethod(ServiceRateController::class, 'normalizeOptionalQueryValue');
+    $reflection->setAccessible(true);
+    expect($reflection->invoke($controller, ['not-a-string']))->toBeNull()
+        ->and($reflection->invoke($controller, ' keep-me '))->toBe('keep-me');
+
+    // The real servicable-rate resolver runs its query against sqlite
+    $connection = new Illuminate\Database\SQLiteConnection(new PDO('sqlite::memory:'));
+    $resolver   = new Illuminate\Database\ConnectionResolver(['default' => $connection, 'mysql' => $connection]);
+    $resolver->setDefaultConnection('mysql');
+    Illuminate\Database\Eloquent\Model::setConnectionResolver($resolver);
+    $schema = $connection->getSchemaBuilder();
+    foreach (['service_rates' => ['uuid', 'public_id', 'company_uuid', 'service_area_uuid', 'zone_uuid', 'service_name', 'service_type', 'base_fee', 'currency', 'rate_calculation_method', 'meta', '_key'], 'service_areas' => ['uuid', 'public_id', 'company_uuid', 'name', 'border', '_key'], 'zones' => ['uuid', 'public_id', 'company_uuid', 'service_area_uuid', 'name', 'border', '_key']] 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();
+        });
+    }
+    $realReflection = new ReflectionMethod(ServiceRateController::class, 'getServicableForWaypoints');
+    $realReflection->setAccessible(true);
+    $servicable = $realReflection->invoke(new ServiceRateController(), collect([]), function ($query) {
+        $query->where('company_uuid', 'company_test');
+    });
+    expect($servicable)->toBeArray();
+
+    // Exports stream through the excel facade
+    if (!class_exists('Fleetbase\\Http\\Requests\\ExportRequest', false)) {
+        eval('namespace Fleetbase\\Http\\Requests; class ExportRequest extends \\Illuminate\\Http\\Request { public function array($key, $default = []) { return (array) $this->input($key, $default); } }');
+    }
+    $excelFake = new class {
+        public array $downloads = [];
+
+        public function download($export, $fileName)
+        {
+            $this->downloads[] = [$export, $fileName];
+
+            return 'excel-download';
+        }
+
+        public function __call($method, $arguments)
+        {
+            return null;
+        }
+    };
+    app()->instance('excel', $excelFake);
+    Maatwebsite\Excel\Facades\Excel::clearResolvedInstance('excel');
+
+    $exportRequest = Fleetbase\Http\Requests\ExportRequest::create('/int/v1/service-rates/export', 'POST', ['format' => 'csv', 'selections' => ['rate-1']]);
+    expect(ServiceRateController::export($exportRequest))->toBe('excel-download')
+        ->and($excelFake->downloads[0][1])->toEndWith('.csv');
+});