@fleetbase/fleetops-engine 0.6.58 → 0.6.59

package/server/tests/Unit/Exports/VehicleExportTest.php

@@ -0,0 +1,284 @@
+<?php
+
+use Fleetbase\FleetOps\Exports\VehicleExport;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Illuminate\Container\Container;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Support\Carbon;
+use Illuminate\Support\Facades\Facade;
+use PhpOffice\PhpSpreadsheet\Style\NumberFormat;
+
+class FleetOpsVehicleExportProbe extends VehicleExport
+{
+    public function assignedOrdersCountForTest(Vehicle $vehicle): int
+    {
+        return $this->assignedOrdersCount($vehicle);
+    }
+
+    public function currentOrderReferenceForTest(Vehicle $vehicle): ?string
+    {
+        return $this->currentOrderReference($vehicle);
+    }
+
+    public function locationPartForTest($location, string $part)
+    {
+        return $this->locationPart($location, $part);
+    }
+
+    public function moneyForTest($amount, ?string $currency = 'USD'): ?string
+    {
+        return $this->money($amount, $currency);
+    }
+}
+
+class FleetOpsVehicleExportDatabaseProbe
+{
+    public function __construct(private SQLiteConnection $connection)
+    {
+    }
+
+    public function connection(): SQLiteConnection
+    {
+        return $this->connection;
+    }
+}
+
+function fleetopsVehicleExportUseInMemoryConnection(): SQLiteConnection
+{
+    $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
+    $connection->statement('create table orders (uuid varchar(64), public_id varchar(64), tracking varchar(64), vehicle_assigned_uuid varchar(64), status varchar(64), created_at datetime null, deleted_at datetime null)');
+
+    $resolver = new ConnectionResolver([
+        'default' => $connection,
+        'mysql'   => $connection,
+    ]);
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+
+    $app = function_exists('app') ? app() : Container::getInstance();
+    if (!$app) {
+        $app = new Container();
+        Container::setInstance($app);
+    }
+
+    Facade::setFacadeApplication($app);
+    $app->instance('db', new FleetOpsVehicleExportDatabaseProbe($connection));
+
+    return $connection;
+}
+
+function fleetopsVehicleExportVehicle(array $attributes = []): Vehicle
+{
+    $vehicle = new Vehicle();
+    $vehicle->setRawAttributes(array_merge([
+        'uuid'                                 => 'vehicle-export-1',
+        'public_id'                            => 'vehicle_public_1',
+        'internal_id'                          => 'veh-internal',
+        'name'                                 => 'Reefer Truck 12',
+        'description'                          => 'Primary cold-chain truck',
+        'plate_number'                         => 'S1234',
+        'vin'                                  => '1FTFW1ET0EKE12345',
+        'make'                                 => 'Ford',
+        'model'                                => 'F-150',
+        'year'                                 => 2026,
+        'trim'                                 => 'XL',
+        'color'                                => 'white',
+        'serial_number'                        => 'serial-12',
+        'fuel_card_number'                     => 'fuel-card-77',
+        'class'                                => 'light-duty',
+        'type'                                 => 'truck',
+        'status'                               => 'available',
+        'online'                               => true,
+        'call_sign'                            => 'COLD-12',
+        'location'                             => ['type' => 'Point', 'coordinates' => [103.851959, 1.29027]],
+        'heading'                              => 135,
+        'altitude'                             => 30,
+        'speed'                                => 42,
+        'measurement_system'                   => 'metric',
+        'fuel_volume_unit'                     => 'liter',
+        'odometer'                             => 50200,
+        'odometer_unit'                        => 'km',
+        'odometer_at_purchase'                 => 1200,
+        'body_type'                            => 'box',
+        'body_sub_type'                        => 'refrigerated',
+        'usage_type'                           => 'delivery',
+        'ownership_type'                       => 'owned',
+        'fuel_type'                            => 'diesel',
+        'transmission'                         => 'automatic',
+        'engine_number'                        => 'engine-12',
+        'engine_make'                          => 'Cummins',
+        'engine_model'                         => 'X12',
+        'engine_family'                        => 'X',
+        'engine_configuration'                 => 'inline',
+        'cylinder_arrangement'                 => 'I6',
+        'number_of_cylinders'                  => 6,
+        'engine_size'                          => 6.7,
+        'engine_displacement'                  => 6700,
+        'horsepower'                           => 300,
+        'horsepower_rpm'                       => 2500,
+        'torque'                               => 900,
+        'torque_rpm'                           => 1600,
+        'fuel_capacity'                        => 120,
+        'payload_capacity'                     => 1500,
+        'towing_capacity'                      => 3000,
+        'seating_capacity'                     => 2,
+        'weight'                               => 4200,
+        'length'                               => 620,
+        'width'                                => 220,
+        'height'                               => 260,
+        'cargo_volume'                         => 35,
+        'payload_capacity_volume'              => 18.5,
+        'payload_capacity_pallets'             => 6,
+        'payload_capacity_parcels'             => 80,
+        'passenger_volume'                     => 3,
+        'interior_volume'                      => 4,
+        'ground_clearance'                     => 22,
+        'bed_length'                           => 240,
+        'emission_standard'                    => 'Euro 6',
+        'dpf_equipped'                         => true,
+        'scr_equipped'                         => false,
+        'gvwr'                                 => 6500,
+        'gcwr'                                 => 9000,
+        'currency'                             => 'USD',
+        'acquisition_cost'                     => 1250000,
+        'current_value'                        => 990000,
+        'insurance_value'                      => 1100000,
+        'depreciation_rate'                    => 12,
+        'estimated_service_life_distance'      => 300000,
+        'estimated_service_life_distance_unit' => 'km',
+        'estimated_service_life_months'        => 72,
+        'purchased_at'                         => '2026-01-01 00:00:00',
+        'lease_expires_at'                     => '2028-01-01 00:00:00',
+        'financing_status'                     => 'financed',
+        'loan_amount'                          => 8000,
+        'loan_number_of_payments'              => 36,
+        'loan_first_payment'                   => '2026-02-01',
+        'skills'                               => ['cold-chain', null, 'hazmat'],
+        'time_window_start'                    => '08:00',
+        'time_window_end'                      => '18:00',
+        'max_tasks'                            => 10,
+        'return_to_depot'                      => true,
+        'notes'                                => 'Use for high-priority chilled cargo.',
+        'created_at'                           => '2026-01-10 12:00:00',
+        'updated_at'                           => '2026-07-26 10:00:00',
+    ], $attributes), true);
+
+    $vehicle->setRelation('driver', (object) [
+        'name'         => 'Ada Driver',
+        'currentOrder' => (object) ['tracking' => 'TRK-RELATION'],
+    ]);
+    $vehicle->setRelation('vendor', (object) ['name' => 'Fleet Vendor']);
+
+    return $vehicle;
+}
+
+test('vehicle export maps complete vehicle rows into spreadsheet headings', function () {
+    $connection = fleetopsVehicleExportUseInMemoryConnection();
+    $connection->table('orders')->insert([
+        [
+            'uuid'                  => 'assigned-order-1',
+            'public_id'             => 'order_public_1',
+            'tracking'              => 'TRK-1',
+            'vehicle_assigned_uuid' => 'vehicle-export-1',
+            'status'                => 'dispatched',
+            'created_at'            => '2026-07-26 08:00:00',
+            'deleted_at'            => null,
+        ],
+        [
+            'uuid'                  => 'assigned-order-2',
+            'public_id'             => 'order_public_2',
+            'tracking'              => 'TRK-2',
+            'vehicle_assigned_uuid' => 'vehicle-export-1',
+            'status'                => 'completed',
+            'created_at'            => '2026-07-25 08:00:00',
+            'deleted_at'            => null,
+        ],
+    ]);
+
+    $export = new VehicleExport();
+    $row    = array_combine($export->headings(), $export->map(fleetopsVehicleExportVehicle()));
+
+    expect($row)->toHaveCount(count($export->headings()))
+        ->and($row['ID'])->toBe('vehicle_public_1')
+        ->and($row['Name'])->toBe('Reefer Truck 12')
+        ->and($row['Driver'])->toBe('Ada Driver')
+        ->and($row['Vendor'])->toBe('Fleet Vendor')
+        ->and($row['Online'])->toBe('Yes')
+        ->and($row['Latitude'])->toBe(1.29027)
+        ->and($row['Longitude'])->toBe(103.851959)
+        ->and($row['DPF Equipped'])->toBe('Yes')
+        ->and($row['SCR Equipped'])->toBe('No')
+        ->and($row['Acquisition Cost'])->toBe('$12,500.00')
+        ->and($row['Current Value'])->toBe('$9,900.00')
+        ->and($row['Insurance Value'])->toBe('$11,000.00')
+        ->and($row['Loan Amount'])->toBe('$8,000.00')
+        ->and($row['Vehicle Skills'])->toBe('cold-chain, hazmat')
+        ->and($row['Return To Depot'])->toBe('Yes')
+        ->and($row['Assigned Order Count'])->toBe(2)
+        ->and($row['Current Order Reference'])->toBe('TRK-RELATION')
+        ->and($row['Notes'])->toBe('Use for high-priority chilled cargo.');
+});
+
+test('vehicle export formats columns and helper fallbacks', function () {
+    $connection = fleetopsVehicleExportUseInMemoryConnection();
+    $connection->table('orders')->insert([
+        [
+            'uuid'                  => 'completed-order',
+            'public_id'             => 'completed_public',
+            'tracking'              => 'TRK-COMPLETE',
+            'vehicle_assigned_uuid' => 'vehicle-export-2',
+            'status'                => 'completed',
+            'created_at'            => '2026-07-26 08:00:00',
+            'deleted_at'            => null,
+        ],
+        [
+            'uuid'                  => 'active-order',
+            'public_id'             => 'active_public',
+            'tracking'              => null,
+            'vehicle_assigned_uuid' => 'vehicle-export-2',
+            'status'                => 'started',
+            'created_at'            => '2026-07-26 09:00:00',
+            'deleted_at'            => null,
+        ],
+    ]);
+
+    $vehicle = fleetopsVehicleExportVehicle([
+        'uuid'             => 'vehicle-export-2',
+        'name'             => '',
+        'currency'         => '',
+        'online'           => null,
+        'location'         => null,
+        'acquisition_cost' => '',
+        'skills'           => 'oversized',
+    ]);
+    $vehicle->setRelation('driver', (object) ['name' => null, 'currentOrder' => null]);
+
+    $export  = new FleetOpsVehicleExportProbe();
+    $formats = $export->columnFormats();
+    $row     = array_combine($export->headings(), $export->map($vehicle));
+
+    expect($formats)->toMatchArray([
+        'CA' => NumberFormat::FORMAT_DATE_DDMMYYYY,
+        'CB' => NumberFormat::FORMAT_DATE_DDMMYYYY,
+        'CF' => NumberFormat::FORMAT_DATE_DDMMYYYY,
+        'CO' => NumberFormat::FORMAT_DATE_DDMMYYYY,
+        'CP' => NumberFormat::FORMAT_DATE_DDMMYYYY,
+    ])
+        ->and($row['Name'])->toBe('2026 Ford F-150 XL')
+        ->and($row['Online'])->toBeNull()
+        ->and($row['Latitude'])->toBe(0.0)
+        ->and($row['Longitude'])->toBe(0.0)
+        ->and($row['Currency'])->toBe('')
+        ->and($row['Acquisition Cost'])->toBeNull()
+        ->and($row['Vehicle Skills'])->toBe('oversized')
+        ->and($row['Current Order Reference'])->toBe('active_public')
+        ->and($export->assignedOrdersCountForTest($vehicle))->toBe(2)
+        ->and($export->currentOrderReferenceForTest($vehicle))->toBe('active_public')
+        ->and($export->locationPartForTest((object) ['latitude' => 12.34, 'longitude' => 56.78], 'lat'))->toBe(12.34)
+        ->and($export->locationPartForTest((object) ['latitude' => 12.34, 'longitude' => 56.78], 'lng'))->toBe(56.78)
+        ->and($export->moneyForTest(12345, null))->toBe('$123.45');
+
+    Carbon::setTestNow();
+});

package/server/tests/Unit/Flow/EventFiringTest.php

@@ -0,0 +1,95 @@
+<?php
+
+use Fleetbase\FleetOps\Flow\Activity;
+use Fleetbase\FleetOps\Flow\Event;
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Models\Waypoint;
+
+/**
+ * Covers Flow\Event::fire(): a name that resolves to a real event class is
+ * instantiated with the order, decorated with the activity and waypoint, and
+ * dispatched. Names with no matching class dispatch nothing.
+ */
+class FleetOpsFlowEventRecorder
+{
+    public static array $fired = [];
+}
+
+if (!Illuminate\Support\Str::hasMacro('humanize')) {
+    Illuminate\Support\Str::macro('humanize', fn ($value, $uppercase = true) => str_replace('_', ' ', Illuminate\Support\Str::snake((string) $value)));
+}
+
+if (!function_exists('Fleetbase\Events\logger')) {
+    eval('namespace Fleetbase\Events; function logger($message = null, array $context = []) { return new class { public function __call($m, $a) { return null; } }; }');
+}
+
+if (!function_exists('Fleetbase\FleetOps\Flow\event')) {
+    eval('namespace Fleetbase\FleetOps\Flow; function event($event = null) { \FleetOpsFlowEventRecorder::$fired[] = $event; return $event; }');
+}
+
+function fleetopsFlowEventBoot(): Illuminate\Database\SQLiteConnection
+{
+    $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);
+    app()->instance('db', new class($connection) {
+        public function __construct(public $c)
+        {
+        }
+
+        public function connection($name = null)
+        {
+            return $this->c;
+        }
+
+        public function __call($method, $arguments)
+        {
+            return $this->c->{$method}(...$arguments);
+        }
+    });
+    Illuminate\Support\Facades\DB::clearResolvedInstance('db');
+
+    $schema = $connection->getSchemaBuilder();
+    foreach (['orders', 'payloads', 'drivers', 'companies', 'waypoints', 'tracking_numbers'] as $table) {
+        $schema->create($table, function ($blueprint) {
+            $blueprint->increments('id');
+            foreach (['uuid', 'public_id', 'company_uuid', 'payload_uuid', 'driver_assigned_uuid', 'status', 'type', '_key'] as $column) {
+                $blueprint->string($column)->nullable();
+            }
+            $blueprint->timestamps();
+            $blueprint->timestamp('deleted_at')->nullable();
+        });
+    }
+
+    session(['company' => 'company-flow-1']);
+
+    return $connection;
+}
+
+test('flow events dispatch resolved classes carrying activity and waypoint', function () {
+    fleetopsFlowEventBoot();
+    FleetOpsFlowEventRecorder::$fired = [];
+
+    $order = new Order();
+    $order->setRawAttributes(['uuid' => 'order-flow-1', 'public_id' => 'order_flowone'], true);
+
+    $waypoint = new Waypoint();
+    $waypoint->setRawAttributes(['uuid' => 'waypoint-flow-1'], true);
+
+    $activity = new Activity(['key' => 'order_completed', 'code' => 'completed', 'status' => 'Completed', 'details' => 'Done'], []);
+
+    // entity_completed resolves to the EntityCompleted event class
+    $event = new Event('order_dispatched', $order);
+    $event->fire($order, $activity, $waypoint);
+
+    expect(FleetOpsFlowEventRecorder::$fired)->toHaveCount(1)
+        ->and(FleetOpsFlowEventRecorder::$fired[0])->toBeInstanceOf(Fleetbase\FleetOps\Events\OrderDispatched::class)
+        ->and(FleetOpsFlowEventRecorder::$fired[0]->activity)->toBe($activity)
+        ->and(FleetOpsFlowEventRecorder::$fired[0]->waypoint)->toBe($waypoint);
+
+    // A name with no matching event class dispatches nothing
+    FleetOpsFlowEventRecorder::$fired = [];
+    (new Event('definitely_not_an_event', $order))->fire($order, $activity, $waypoint);
+    expect(FleetOpsFlowEventRecorder::$fired)->toHaveCount(0);
+});

package/server/tests/Unit/Http/Api/QueryWithRequestSeamsTest.php

@@ -0,0 +1,198 @@
+<?php
+
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Http\Request;
+
+/**
+ * Covers the queryWithRequest seam every public API controller exposes. Each
+ * one hands the request to its model's request-driven query builder, and the
+ * result is scoped to the session company.
+ */
+if (!function_exists('Fleetbase\Support\auth')) {
+    eval('namespace Fleetbase\Support; function auth() { return new class { public function user() { return null; } public function id() { return null; } public function check() { return false; } }; }');
+}
+
+if (!function_exists('Fleetbase\Support\session')) {
+    eval('namespace Fleetbase\Support; function session($key = null, $default = null) { if ($key === null) { return new class { public function has($k) { return \session($k) !== null; } public function get($k, $d = null) { return \session($k, $d); } }; } return \session($key, $default); }');
+}
+
+if (!Request::hasMacro('getController')) {
+    // Resolve the controller named by the current route action
+    Request::macro('getController', function () {
+        $action = $this->route()?->getAction('controller');
+
+        return $action ? app(explode('@', $action)[0]) : null;
+    });
+}
+
+if (!Request::hasMacro('or')) {
+    Request::macro('or', function (array $params = [], $default = null) {
+        foreach ($params as $param) {
+            if ($this->has($param)) {
+                return $this->input($param);
+            }
+        }
+
+        return $default;
+    });
+}
+
+function fleetopsQwrBoot(): SQLiteConnection
+{
+    $pdo = new PDO('sqlite::memory:');
+    foreach (['ST_PointFromText', 'ST_GeomFromText'] as $spatialFunction) {
+        $pdo->sqliteCreateFunction($spatialFunction, fn ($wkt, $srid = 0, $axisOrder = null) => $wkt);
+    }
+    $connection = new SQLiteConnection($pdo);
+    $resolver   = new ConnectionResolver(['default' => $connection, 'mysql' => $connection]);
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+    if (!EloquentModel::getEventDispatcher()) {
+        EloquentModel::setEventDispatcher(new Illuminate\Events\Dispatcher());
+    }
+    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('responsecache', new class {
+        public function __call($method, $arguments)
+        {
+            return null;
+        }
+    });
+    config()->set('activitylog.enabled', false);
+    config()->set('activitylog.default_auth_driver', 'web');
+    app()->bind(Illuminate\Contracts\Config\Repository::class, fn () => config());
+
+    $columns = [
+        'uuid', 'public_id', 'internal_id', 'company_uuid', 'name', 'type', 'status', 'meta', '_key',
+        'owner_uuid', 'owner_type', 'payload_uuid', 'order_uuid', 'place_uuid', 'tracking_number_uuid',
+        'service_area_uuid', 'zone_uuid', 'vendor_uuid', 'driver_uuid', 'vehicle_uuid', 'device_uuid',
+        'code', 'details', 'report', 'key', 'namespace', 'border', 'location', 'expired_at',
+        'permission_uuid', 'subject_type', 'subject_uuid', 'rules',
+    ];
+
+    $schema = $connection->getSchemaBuilder();
+    foreach ([
+        'contacts', 'devices', 'entities', 'equipments', 'fleets', 'fuel_reports', 'fuel_provider_transactions',
+        'issues', 'order_configs', 'parts', 'payloads', 'places', 'service_areas', 'service_rates',
+        'tracking_numbers', 'tracking_statuses', 'vendors', 'work_orders', 'zones', 'directives', 'companies', 'waypoints',
+    ] as $table) {
+        $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-qwr-1']);
+    $connection->table('companies')->insert(['uuid' => 'company-qwr-1', 'name' => 'Query Co']);
+
+    return $connection;
+}
+
+function fleetopsQwrRequest(string $controllerClass, string $uri): Request
+{
+    $request = Request::create($uri, 'GET');
+    $store   = app('session.store');
+    $store->put('company', 'company-qwr-1');
+    $request->setLaravelSession($store);
+    $request->setRouteResolver(fn () => new class($controllerClass) {
+        public function __construct(private string $controllerClass)
+        {
+        }
+
+        public function getAction($key = null)
+        {
+            $action = $this->controllerClass . '@query';
+
+            return $key === null ? ['controller' => $action] : $action;
+        }
+
+        public function getActionMethod()
+        {
+            return 'query';
+        }
+
+        public function getName()
+        {
+            return 'api.v1.query';
+        }
+
+        public function uri()
+        {
+            return 'v1/resource';
+        }
+
+        public function parameters()
+        {
+            return [];
+        }
+
+        public function parameter($name = null, $default = null)
+        {
+            return $default;
+        }
+    });
+
+    app()->instance('request', $request);
+
+    return $request;
+}
+
+test('api controllers query their model through the request pipeline', function (string $controllerClass, string $method, string $table, bool $takesCallback) {
+    $connection = fleetopsQwrBoot();
+    $connection->table($table)->insert([
+        ['uuid' => 'qwr-row-1', 'public_id' => 'qwr_row_one', 'company_uuid' => 'company-qwr-1', 'name' => 'In Company'],
+        ['uuid' => 'qwr-row-2', 'public_id' => 'qwr_row_two', 'company_uuid' => 'company-other', 'name' => 'Other Company'],
+    ]);
+
+    // Controllers with constructor dependencies resolve through the container
+    $controller = app($controllerClass);
+    $reflection = new ReflectionMethod($controllerClass, $method);
+    $reflection->setAccessible(true);
+
+    $request   = fleetopsQwrRequest($controllerClass, '/v1/resource');
+    $arguments = $takesCallback ? [$request, function (&$query) {}] : [$request];
+    $results   = $reflection->invoke($controller, ...$arguments);
+
+    // Only the session company's records come back
+    expect(collect($results)->pluck('uuid')->all())->toBe(['qwr-row-1']);
+})->with([
+    'contacts'          => [Fleetbase\FleetOps\Http\Controllers\Api\v1\ContactController::class, 'queryContacts', 'contacts', false],
+    'entities'          => [Fleetbase\FleetOps\Http\Controllers\Api\v1\EntityController::class, 'queryEntities', 'entities', false],
+    'fleets'            => [Fleetbase\FleetOps\Http\Controllers\Api\v1\FleetController::class, 'queryFleets', 'fleets', false],
+    'fuel reports'      => [Fleetbase\FleetOps\Http\Controllers\Api\v1\FuelReportController::class, 'queryFuelReports', 'fuel_reports', false],
+    'issues'            => [Fleetbase\FleetOps\Http\Controllers\Api\v1\IssueController::class, 'queryIssues', 'issues', false],
+    'order configs'     => [Fleetbase\FleetOps\Http\Controllers\Api\v1\OrderConfigController::class, 'queryOrderConfigs', 'order_configs', false],
+    'payloads'          => [Fleetbase\FleetOps\Http\Controllers\Api\v1\PayloadController::class, 'queryPayloads', 'payloads', false],
+    'service areas'     => [Fleetbase\FleetOps\Http\Controllers\Api\v1\ServiceAreaController::class, 'queryServiceAreas', 'service_areas', false],
+    'service rates'     => [Fleetbase\FleetOps\Http\Controllers\Api\v1\ServiceRateController::class, 'queryServiceRates', 'service_rates', false],
+    'tracking numbers'  => [Fleetbase\FleetOps\Http\Controllers\Api\v1\TrackingNumberController::class, 'queryTrackingNumbers', 'tracking_numbers', false],
+    'tracking statuses' => [Fleetbase\FleetOps\Http\Controllers\Api\v1\TrackingStatusController::class, 'queryTrackingStatuses', 'tracking_statuses', false],
+    'vendors'           => [Fleetbase\FleetOps\Http\Controllers\Api\v1\VendorController::class, 'queryVendors', 'vendors', false],
+    'zones'             => [Fleetbase\FleetOps\Http\Controllers\Api\v1\ZoneController::class, 'queryZones', 'zones', false],
+    'devices'           => [Fleetbase\FleetOps\Http\Controllers\Api\v1\DeviceController::class, 'queryDevicesWithRequest', 'devices', true],
+    'equipment'         => [Fleetbase\FleetOps\Http\Controllers\Api\v1\EquipmentController::class, 'queryEquipment', 'equipments', true],
+    'fuel transactions' => [Fleetbase\FleetOps\Http\Controllers\Api\v1\FuelTransactionController::class, 'queryTransactionsWithRequest', 'fuel_provider_transactions', true],
+    'parts'             => [Fleetbase\FleetOps\Http\Controllers\Api\v1\PartController::class, 'queryParts', 'parts', true],
+    'places'            => [Fleetbase\FleetOps\Http\Controllers\Api\v1\PlaceController::class, 'queryPlaces', 'places', true],
+    'work orders'       => [Fleetbase\FleetOps\Http\Controllers\Api\v1\WorkOrderController::class, 'queryWorkOrdersWithRequest', 'work_orders', true],
+]);

package/server/tests/Unit/Http/Api/SensorInputTest.php

@@ -0,0 +1,95 @@
+<?php
+
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Http\Request;
+
+/**
+ * Covers input mapping on the sensor API: a filled `sensorable` resolves to
+ * its morph type and uuid, while a blank one clears both.
+ */
+if (!function_exists('Fleetbase\Support\session')) {
+    eval('namespace Fleetbase\Support; function session($key = null, $default = null) { if ($key === null) { return new class { public function has($k) { return \session($k) !== null; } public function get($k, $d = null) { return \session($k, $d); } }; } return \session($key, $default); }');
+}
+
+function fleetopsSensorInputBoot(): SQLiteConnection
+{
+    $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
+    $resolver   = new ConnectionResolver(['default' => $connection, 'mysql' => $connection]);
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+    if (!EloquentModel::getEventDispatcher()) {
+        EloquentModel::setEventDispatcher(new Illuminate\Events\Dispatcher());
+    }
+    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('responsecache', new class {
+        public function __call($method, $arguments)
+        {
+            return null;
+        }
+    });
+    config()->set('activitylog.enabled', false);
+    app()->bind(Illuminate\Contracts\Config\Repository::class, fn () => config());
+
+    $schema = $connection->getSchemaBuilder();
+    foreach (['vehicles', 'devices', 'sensors'] as $table) {
+        $schema->create($table, function ($blueprint) {
+            $blueprint->increments('id');
+            foreach (['uuid', 'public_id', 'company_uuid', 'name', 'type', 'status', 'sensorable_uuid', 'sensorable_type', '_key'] as $column) {
+                $blueprint->string($column)->nullable();
+            }
+            $blueprint->timestamps();
+            $blueprint->timestamp('deleted_at')->nullable();
+        });
+    }
+
+    session(['company' => 'company-sensor-1']);
+    $connection->table('vehicles')->insert(['uuid' => 'vehicle-sensor-1', 'public_id' => 'vehicle_sensorone', 'company_uuid' => 'company-sensor-1']);
+
+    return $connection;
+}
+
+test('sensor input resolves and clears its morph target', function () {
+    fleetopsSensorInputBoot();
+
+    $class      = Fleetbase\FleetOps\Http\Controllers\Api\v1\SensorController::class;
+    $controller = (new ReflectionClass($class))->newInstanceWithoutConstructor();
+    $reflection = new ReflectionMethod($class, 'input');
+    $reflection->setAccessible(true);
+
+    // A filled sensorable resolves to the morph class and its uuid
+    $attached = $reflection->invoke($controller, Request::create('/v1/sensors', 'POST', [
+        'name'            => 'Cargo Temp',
+        'sensorable'      => 'vehicle_sensorone',
+        // the short name resolves to a nonexistent \Fleetbase\Models\Vehicle
+        'sensorable_type' => Fleetbase\FleetOps\Models\Vehicle::class,
+    ]));
+
+    expect($attached['sensorable_uuid'])->toBe('vehicle-sensor-1')
+        ->and($attached['sensorable_type'])->toContain('Vehicle');
+
+    // An explicitly blank sensorable detaches the sensor
+    $detached = $reflection->invoke($controller, Request::create('/v1/sensors', 'POST', [
+        'name'       => 'Cargo Temp',
+        'sensorable' => '',
+    ]));
+
+    expect($detached['sensorable_uuid'])->toBeNull()
+        ->and($detached['sensorable_type'])->toBeNull();
+});