@fleetbase/fleetops-engine 0.6.57 → 0.6.59

package/server/tests/Unit/Http/Filter/DeviceFilterTest.php

@@ -0,0 +1,199 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Filter\DeviceFilter;
+use Fleetbase\Http\Filter\Filter;
+use Illuminate\Http\Request;
+use Illuminate\Support\Carbon;
+
+if (!function_exists('Fleetbase\FleetOps\Http\Filter\now')) {
+    eval('namespace Fleetbase\FleetOps\Http\Filter; function now($tz = null) { return \Illuminate\Support\Carbon::now($tz); }');
+}
+
+class FleetOpsDeviceFilterUnitQuery
+{
+    public array $calls = [];
+
+    public function where(...$arguments): self
+    {
+        if (isset($arguments[0]) && is_callable($arguments[0])) {
+            $nested = new self();
+            $arguments[0]($nested);
+            $this->calls[] = ['whereNested', $nested->calls];
+
+            return $this;
+        }
+
+        $this->calls[] = ['where', $arguments];
+
+        return $this;
+    }
+
+    public function search(?string $query): self
+    {
+        $this->calls[] = ['search', $query];
+
+        return $this;
+    }
+
+    public function whereIn(string $column, mixed $values): self
+    {
+        $this->calls[] = ['whereIn', $column, $values];
+
+        return $this;
+    }
+
+    public function whereNotNull(string $column): self
+    {
+        $this->calls[] = ['whereNotNull', $column];
+
+        return $this;
+    }
+
+    public function whereNull(string $column): self
+    {
+        $this->calls[] = ['whereNull', $column];
+
+        return $this;
+    }
+
+    public function orWhere(...$arguments): self
+    {
+        $this->calls[] = ['orWhere', $arguments];
+
+        return $this;
+    }
+
+    public function orWhereBetween(string $column, array $bounds): self
+    {
+        $this->calls[] = ['orWhereBetween', $column, $bounds];
+
+        return $this;
+    }
+
+    public function orWhereNull(string $column): self
+    {
+        $this->calls[] = ['orWhereNull', $column];
+
+        return $this;
+    }
+
+    public function whereBetween(string $column, array $bounds): self
+    {
+        $this->calls[] = ['whereBetween', $column, $bounds];
+
+        return $this;
+    }
+
+    public function whereDate(string $column, string $date): self
+    {
+        $this->calls[] = ['whereDate', $column, $date];
+
+        return $this;
+    }
+}
+
+function fleetopsDeviceFilterUnitFilter(FleetOpsDeviceFilterUnitQuery $builder, ?Request $request = null): DeviceFilter
+{
+    $filter = (new ReflectionClass(DeviceFilter::class))->newInstanceWithoutConstructor();
+
+    foreach ([
+        'builder' => $builder,
+        'session' => new class {
+            public function get(string $key): ?string
+            {
+                return $key === 'company' ? 'company-uuid' : null;
+            }
+        },
+        'request' => $request ?? new Request(),
+    ] as $property => $value) {
+        $reflection = new ReflectionProperty(Filter::class, $property);
+        $reflection->setAccessible(true);
+        $reflection->setValue($filter, $value);
+    }
+
+    return $filter;
+}
+
+test('device filter records empty relation attachment online and date branches', function () {
+    Carbon::setTestNow(Carbon::parse('2026-07-27 12:00:00'));
+
+    $builder = new FleetOpsDeviceFilterUnitQuery();
+    $filter  = fleetopsDeviceFilterUnitFilter($builder);
+
+    $filter->queryForInternal();
+    $filter->queryForPublic();
+    $filter->query('temperature probe');
+    $filter->status([]);
+    $filter->deviceId(null);
+    $filter->type(null);
+    $filter->serialNumber(null);
+    $filter->telematic(null);
+    $filter->telematicUuid(null);
+    $filter->vehicle(null);
+    $filter->connectionStatus('');
+    $filter->connectionStatus(['online', 'never_connected']);
+    $filter->attachmentState('attached');
+    $filter->attachmentState('ignored');
+    $filter->lastOnlineAt(['2026-07-01', '2026-07-15']);
+    $filter->updatedAt('2026-07-20');
+
+    expect($builder->calls)->toContain(['where', ['company_uuid', 'company-uuid']])
+        ->and($builder->calls)->toContain(['search', 'temperature probe'])
+        ->and($builder->calls)->toContain(['whereNotNull', 'attachable_uuid']);
+
+    $connectionStatus = collect($builder->calls)->filter(fn ($call) => $call[0] === 'whereNested' && count($call[1]) > 0)->first();
+    $lastOnlineRange  = collect($builder->calls)->first(fn ($call) => $call[0] === 'whereBetween' && $call[1] === 'last_online_at');
+    $updatedAtDate    = collect($builder->calls)->first(fn ($call) => $call[0] === 'whereDate' && $call[1] === 'updated_at');
+
+    expect($connectionStatus[1])->toHaveCount(2)
+        ->and($connectionStatus[1][0][0])->toBe('orWhere')
+        ->and($connectionStatus[1][0][1][0])->toBe('last_online_at')
+        ->and($connectionStatus[1][0][1][1])->toBe('>=')
+        ->and($connectionStatus[1][0][1][2]->toDateTimeString())->toBe('2026-07-27 11:50:00')
+        ->and($connectionStatus[1][1])->toBe(['orWhereNull', 'last_online_at'])
+        ->and($lastOnlineRange[2][0]->toDateString())->toBe('2026-07-01')
+        ->and($lastOnlineRange[2][1]->toDateString())->toBe('2026-07-15')
+        ->and($updatedAtDate[2])->toBe('2026-07-20 00:00:00');
+
+    expect(collect($builder->calls)->where(0, 'whereIn'))->toHaveCount(0)
+        ->and(collect($builder->calls)->where(0, 'whereNull'))->toHaveCount(0);
+
+    Carbon::setTestNow();
+});
+
+test('device relation identifiers resolve public and internal uuids', function () {
+    $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 (['vehicles' => ['uuid', 'public_id', 'company_uuid', 'internal_id', 'name'], 'devices' => ['uuid', 'public_id', 'company_uuid', 'attachable_uuid', 'attachable_type', 'name']] 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();
+        });
+    }
+    $connection->table('vehicles')->insert(['uuid' => 'veh-flt-1', 'public_id' => 'vehicle_fltone1', 'company_uuid' => 'company-uuid', 'internal_id' => 'VEH-9', 'name' => 'Filter Van']);
+
+    $builder    = Fleetbase\FleetOps\Models\Device::query();
+    $filter     = fleetopsDeviceFilterUnitFilter(new FleetOpsDeviceFilterUnitQuery());
+    $reflection = new ReflectionProperty(Filter::class, 'builder');
+    $reflection->setAccessible(true);
+    $reflection->setValue($filter, $builder);
+
+    // Public ids and internal ids both resolve through the relation lookup
+    $filter->vehicle('vehicle_fltone1');
+    $filter->vehicle('VEH-9');
+    $sql = $builder->toSql();
+    expect(substr_count($sql, '"attachable_uuid" in'))->toBe(2);
+
+    // The offline connection status branch constrains stale devices
+    $offlineBuilder = new FleetOpsDeviceFilterUnitQuery();
+    $offlineFilter  = fleetopsDeviceFilterUnitFilter($offlineBuilder);
+    $offlineFilter->connectionStatus('offline');
+    expect(collect($offlineBuilder->calls)->where(0, 'whereNested'))->toHaveCount(1);
+});

package/server/tests/Unit/Http/Filter/EmptyValueGuardsTest.php

@@ -0,0 +1,66 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Filter\DeviceEventFilter;
+use Fleetbase\FleetOps\Http\Filter\DeviceFilter;
+use Fleetbase\Http\Filter\Filter;
+use Illuminate\Http\Request;
+
+/**
+ * Covers the empty-value guards on the multi-value device filters. Both accept a
+ * string or an array and normalise it with `Utils::arrayFrom()`; an empty array
+ * normalises to nothing to match on, and the filter must leave the query
+ * untouched rather than emitting a constraint that excludes every row.
+ */
+class FleetOpsEmptyGuardQuery
+{
+    public array $calls = [];
+
+    public function __call(string $method, array $arguments): self
+    {
+        $this->calls[] = $method;
+
+        return $this;
+    }
+}
+
+function fleetopsEmptyGuardFilter(string $filterClass, FleetOpsEmptyGuardQuery $builder): object
+{
+    $filter = (new ReflectionClass($filterClass))->newInstanceWithoutConstructor();
+
+    foreach ([
+        'builder' => $builder,
+        'session' => new class {
+            public function get(string $key): ?string
+            {
+                return $key === 'company' ? 'company-uuid' : null;
+            }
+        },
+        'request' => new Request(),
+    ] as $property => $value) {
+        $reflection = new ReflectionProperty(Filter::class, $property);
+        $reflection->setAccessible(true);
+        $reflection->setValue($filter, $value);
+    }
+
+    return $filter;
+}
+
+test('device filters ignore empty multi value input', function () {
+    // An empty array normalises to no states, so nothing is applied
+    $emptyStatus = new FleetOpsEmptyGuardQuery();
+    fleetopsEmptyGuardFilter(DeviceFilter::class, $emptyStatus)->connectionStatus([]);
+    expect($emptyStatus->calls)->toBe([]);
+
+    $emptyProcessed = new FleetOpsEmptyGuardQuery();
+    fleetopsEmptyGuardFilter(DeviceEventFilter::class, $emptyProcessed)->processed([]);
+    expect($emptyProcessed->calls)->toBe([]);
+
+    // A real value still reaches the builder, so the guard is not swallowing work
+    $withStatus = new FleetOpsEmptyGuardQuery();
+    fleetopsEmptyGuardFilter(DeviceFilter::class, $withStatus)->connectionStatus(['online']);
+    expect($withStatus->calls)->not->toBe([]);
+
+    $withProcessed = new FleetOpsEmptyGuardQuery();
+    fleetopsEmptyGuardFilter(DeviceEventFilter::class, $withProcessed)->processed(['1']);
+    expect($withProcessed->calls)->not->toBe([]);
+});

package/server/tests/Unit/Http/Filter/FilterDateRangesTest.php

@@ -0,0 +1,72 @@
+<?php
+
+use Fleetbase\Http\Filter\Filter;
+use Illuminate\Http\Request;
+
+/**
+ * Covers the shared date filter methods across the request filters: a single
+ * date narrows with whereDate, while a comma separated pair narrows with
+ * whereBetween over the parsed range.
+ */
+class FleetOpsFilterDateQuery
+{
+    public array $calls = [];
+
+    public function __call(string $method, array $arguments): self
+    {
+        $this->calls[] = [$method, $arguments];
+
+        return $this;
+    }
+}
+
+function fleetopsFilterDateInstance(string $filterClass, FleetOpsFilterDateQuery $builder): object
+{
+    $filter = (new ReflectionClass($filterClass))->newInstanceWithoutConstructor();
+
+    foreach ([
+        'builder' => $builder,
+        'session' => new class {
+            public function get(string $key): ?string
+            {
+                return $key === 'company' ? 'company-filter-1' : null;
+            }
+        },
+        'request' => new Request(),
+    ] as $property => $value) {
+        $reflection = new ReflectionProperty(Filter::class, $property);
+        $reflection->setAccessible(true);
+        $reflection->setValue($filter, $value);
+    }
+
+    return $filter;
+}
+
+test('date filters narrow by single dates and parsed ranges', function (string $filterClass, string $method, string $column) {
+    // A single date narrows to that calendar day
+    $singleBuilder = new FleetOpsFilterDateQuery();
+    fleetopsFilterDateInstance($filterClass, $singleBuilder)->{$method}('2026-07-29');
+
+    expect($singleBuilder->calls)->toHaveCount(1)
+        ->and($singleBuilder->calls[0][0])->toBe('whereDate')
+        ->and($singleBuilder->calls[0][1][0])->toBe($column);
+
+    // A comma separated pair narrows to the parsed range
+    $rangeBuilder = new FleetOpsFilterDateQuery();
+    fleetopsFilterDateInstance($filterClass, $rangeBuilder)->{$method}('2026-07-01,2026-07-29');
+
+    expect($rangeBuilder->calls)->toHaveCount(1)
+        ->and($rangeBuilder->calls[0][0])->toBe('whereBetween')
+        ->and($rangeBuilder->calls[0][1][0])->toBe($column)
+        ->and($rangeBuilder->calls[0][1][1])->toHaveCount(2);
+})->with([
+    'contact created'       => [Fleetbase\FleetOps\Http\Filter\ContactFilter::class, 'createdAt', 'created_at'],
+    'contact updated'       => [Fleetbase\FleetOps\Http\Filter\ContactFilter::class, 'updatedAt', 'updated_at'],
+    'fleet created'         => [Fleetbase\FleetOps\Http\Filter\FleetFilter::class, 'createdAt', 'created_at'],
+    'fleet updated'         => [Fleetbase\FleetOps\Http\Filter\FleetFilter::class, 'updatedAt', 'updated_at'],
+    'vendor created'        => [Fleetbase\FleetOps\Http\Filter\VendorFilter::class, 'createdAt', 'created_at'],
+    'vendor updated'        => [Fleetbase\FleetOps\Http\Filter\VendorFilter::class, 'updatedAt', 'updated_at'],
+    'device event created'  => [Fleetbase\FleetOps\Http\Filter\DeviceEventFilter::class, 'createdAt', 'created_at'],
+    'device event updated'  => [Fleetbase\FleetOps\Http\Filter\DeviceEventFilter::class, 'updatedAt', 'updated_at'],
+    'device event occurred' => [Fleetbase\FleetOps\Http\Filter\DeviceEventFilter::class, 'occurredAt', 'occurred_at'],
+]);

package/server/tests/Unit/Http/Filter/FuelProviderTransactionFilterTest.php

@@ -0,0 +1,172 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Filter\FuelProviderTransactionFilter;
+use Fleetbase\Http\Filter\Filter;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Http\Request;
+
+/**
+ * Covers the FuelProviderTransactionFilter public-relation resolution: the
+ * missing-identifier early return, the public-id/internal-id/uuid matching
+ * branches of resolvePublicRelationUuids against a real SQLite fixture, and
+ * the internal-request uuid allowance.
+ */
+class FleetOpsFuelTxnFilterQuery
+{
+    public array $calls = [];
+
+    public function __call($method, $arguments)
+    {
+        $this->calls[] = [$method, $arguments];
+
+        return $this;
+    }
+}
+
+function fleetopsFuelTxnFilterBoot(): 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 = [
+        'vehicles'                  => ['uuid', 'public_id', 'internal_id', 'company_uuid'],
+        'fuel_provider_connections' => ['uuid', 'public_id', 'company_uuid', 'provider', 'credentials'],
+        'drivers'                   => ['uuid', 'public_id', 'internal_id', 'company_uuid', 'user_uuid'],
+        'users'                     => ['uuid', 'public_id', 'company_uuid'],
+        'orders'                    => ['uuid', 'public_id', 'internal_id', 'company_uuid'],
+        'fuel_reports'              => ['uuid', 'public_id', 'company_uuid', 'report'],
+    ];
+    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;
+}
+
+function fleetopsFuelTxnFilter(FleetOpsFuelTxnFilterQuery $builder, ?Request $request = null): FuelProviderTransactionFilter
+{
+    $filter = (new ReflectionClass(FuelProviderTransactionFilter::class))->newInstanceWithoutConstructor();
+
+    foreach ([
+        'builder' => $builder,
+        'session' => new class {
+            public function get(string $key): ?string
+            {
+                return $key === 'company' ? 'company-1' : null;
+            }
+        },
+        'request' => $request ?? new Request(),
+    ] as $property => $value) {
+        $reflection = new ReflectionProperty(Filter::class, $property);
+        $reflection->setAccessible(true);
+        $reflection->setValue($filter, $value);
+    }
+
+    return $filter;
+}
+
+function fleetopsFuelTxnInternalRequest(): Request
+{
+    $request = new Request();
+    $request->setRouteResolver(fn () => new class {
+        public array $action = ['namespace' => 'Fleetbase\FleetOps\Http\Controllers\Internal'];
+
+        public function uri(): string
+        {
+            return 'int/v1/fuel-provider-transactions';
+        }
+    });
+
+    return $request;
+}
+
+test('missing identifiers skip relation constraints entirely', function () {
+    fleetopsFuelTxnFilterBoot();
+    $builder = new FleetOpsFuelTxnFilterQuery();
+    $filter  = fleetopsFuelTxnFilter($builder);
+
+    $filter->vehicle(null);
+    $filter->connection(null);
+    $filter->driver(null);
+    $filter->order(null);
+    $filter->fuelReport(null);
+
+    expect($builder->calls)->toBe([]);
+});
+
+test('public relations resolve uuids by public and internal ids', function () {
+    $connection = fleetopsFuelTxnFilterBoot();
+    $connection->table('vehicles')->insert([
+        ['uuid' => 'vehicle-1', 'public_id' => 'vehicle_abc', 'internal_id' => 'FLEET-9', 'company_uuid' => 'company-1'],
+        ['uuid' => 'vehicle-2', 'public_id' => 'vehicle_other', 'internal_id' => 'OTHER', 'company_uuid' => 'company-2'],
+    ]);
+    $connection->table('fuel_provider_connections')->insert(['uuid' => 'conn-1', 'public_id' => 'fuel_provider_connection_abc', 'company_uuid' => 'company-1']);
+    $connection->table('orders')->insert(['uuid' => 'order-1', 'public_id' => 'order_abc', 'internal_id' => 'ORD-7', 'company_uuid' => 'company-1']);
+    $connection->table('fuel_reports')->insert(['uuid' => 'fr-1', 'public_id' => 'fuel_report_abc', 'company_uuid' => 'company-1']);
+
+    $builder = new FleetOpsFuelTxnFilterQuery();
+    $filter  = fleetopsFuelTxnFilter($builder);
+
+    $filter->vehicle('vehicle_abc');
+    $filter->connection('fuel_provider_connection_abc');
+    $filter->order('ORD-7');
+    $filter->fuelReport('fuel_report_abc');
+
+    $whereIns = collect($builder->calls)->where(0, 'whereIn')->values();
+    expect($whereIns)->toHaveCount(4)
+        ->and($whereIns[0][1][0])->toBe('vehicle_uuid')
+        ->and($whereIns[0][1][1]->all())->toBe(['vehicle-1'])
+        ->and($whereIns[1][1][1]->all())->toBe(['conn-1'])
+        ->and($whereIns[2][1][1]->all())->toBe(['order-1'])
+        ->and($whereIns[3][1][1]->all())->toBe(['fr-1']);
+
+    // Company scoping excludes other companies' matches
+    $filter->vehicle('vehicle_other');
+    $scoped = collect($builder->calls)->where(0, 'whereIn')->last();
+    expect($scoped[1][1]->all())->toBe([]);
+});
+
+test('internal requests may resolve relations by raw uuid', function () {
+    $connection = fleetopsFuelTxnFilterBoot();
+    $connection->table('vehicles')->insert(['uuid' => 'vehicle-1', 'public_id' => 'vehicle_abc', 'internal_id' => 'FLEET-9', 'company_uuid' => 'company-1']);
+
+    // Public requests cannot match by uuid
+    $publicBuilder = new FleetOpsFuelTxnFilterQuery();
+    fleetopsFuelTxnFilter($publicBuilder)->vehicle('vehicle-1');
+    expect(collect($publicBuilder->calls)->where(0, 'whereIn')->last()[1][1]->all())->toBe([]);
+
+    // Internal requests can
+    $internalBuilder = new FleetOpsFuelTxnFilterQuery();
+    fleetopsFuelTxnFilter($internalBuilder, fleetopsFuelTxnInternalRequest())->vehicle('vehicle-1');
+    expect(collect($internalBuilder->calls)->where(0, 'whereIn')->last()[1][1]->all())->toBe(['vehicle-1']);
+});

package/server/tests/Unit/Http/Filter/InternalRelationUuidLookupTest.php

@@ -0,0 +1,135 @@
+<?php
+
+use Fleetbase\Http\Filter\Filter;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Http\Request;
+
+/**
+ * Covers the shared `resolvePublicRelationUuids()` seam that DeviceFilter and
+ * SensorFilter each carry: relation identifiers normally resolve by `public_id`
+ * or `internal_id`, but an internal request additionally allows a raw `uuid` to
+ * be passed. Public requests must not accept uuids, so the two request kinds are
+ * asserted against each other.
+ */
+class FleetOpsInternalFilterRouteFixture
+{
+    public array $action = [];
+
+    public function __construct(private string $uri)
+    {
+    }
+
+    public function uri(): string
+    {
+        return $this->uri;
+    }
+}
+
+function fleetopsInternalFilterRequest(string $uri): Request
+{
+    $request = Request::create('/' . $uri, 'GET');
+    $request->setRouteResolver(fn () => new FleetOpsInternalFilterRouteFixture($uri));
+
+    return $request;
+}
+
+function fleetopsInternalFilterBoot(array $tables): 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();
+    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();
+        });
+    }
+
+    return $connection;
+}
+
+function fleetopsInternalFilterMake(string $filterClass, Request $request, $builder): object
+{
+    $filter = (new ReflectionClass($filterClass))->newInstanceWithoutConstructor();
+
+    foreach ([
+        'builder' => $builder,
+        'session' => new class {
+            public function get(string $key): ?string
+            {
+                return $key === 'company' ? 'company-uuid' : null;
+            }
+        },
+        'request' => $request,
+    ] as $property => $value) {
+        $reflection = new ReflectionProperty(Filter::class, $property);
+        $reflection->setAccessible(true);
+        $reflection->setValue($filter, $value);
+    }
+
+    return $filter;
+}
+
+test('internal requests let relation filters resolve records by raw uuid', function () {
+    $connection = fleetopsInternalFilterBoot([
+        'vehicles' => ['uuid', 'public_id', 'company_uuid', 'internal_id', 'name'],
+        'devices'  => ['uuid', 'public_id', 'company_uuid', 'attachable_uuid', 'attachable_type', 'name'],
+        'sensors'  => ['uuid', 'public_id', 'company_uuid', 'device_uuid', 'name'],
+    ]);
+
+    $connection->table('vehicles')->insert(['uuid' => 'veh-int-1', 'public_id' => 'vehicle_intone', 'company_uuid' => 'company-uuid', 'internal_id' => 'VEH-INT', 'name' => 'Internal Van']);
+    session(['company' => 'company-uuid']);
+
+    $resolve = function (string $filterClass, string $uri, string $modelClass, string $identifier) {
+        $filter     = fleetopsInternalFilterMake($filterClass, fleetopsInternalFilterRequest($uri), $modelClass::query());
+        $reflection = new ReflectionMethod($filterClass, 'resolvePublicRelationUuids');
+        $reflection->setAccessible(true);
+
+        return $reflection->invoke(
+            $filter,
+            $modelClass,
+            $identifier,
+            Fleetbase\Support\Http::isInternalRequest(fleetopsInternalFilterRequest($uri))
+        );
+    };
+
+    $vehicle = Fleetbase\FleetOps\Models\Vehicle::class;
+
+    foreach ([
+        Fleetbase\FleetOps\Http\Filter\DeviceFilter::class,
+        Fleetbase\FleetOps\Http\Filter\SensorFilter::class,
+    ] as $filterClass) {
+        // An internal route resolves the raw uuid, a public route does not
+        expect($resolve($filterClass, 'int/v1/fleet-ops/records', $vehicle, 'veh-int-1')->all())->toBe(['veh-int-1'])
+            ->and($resolve($filterClass, 'v1/records', $vehicle, 'veh-int-1')->all())->toBe([]);
+
+        // Public and internal ids resolve regardless of the route kind
+        expect($resolve($filterClass, 'v1/records', $vehicle, 'vehicle_intone')->all())->toBe(['veh-int-1'])
+            ->and($resolve($filterClass, 'v1/records', $vehicle, 'VEH-INT')->all())->toBe(['veh-int-1']);
+    }
+});