@fleetbase/fleetops-engine 0.6.57 → 0.6.59

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

@@ -0,0 +1,129 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Filter\IssueFilter;
+use Fleetbase\Http\Filter\Filter;
+use Illuminate\Http\Request;
+
+/**
+ * Covers the IssueFilter query branches against a recording builder fake:
+ * base scoping, keyword search, priority and status constraints, and the
+ * assignee, reporter, driver and vehicle relation lookups routing by uuid,
+ * public id, or fallback search.
+ */
+class FleetOpsIssueFilterUnitQuery
+{
+    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 whereHas(string $relation, ?callable $callback = null): self
+    {
+        $nested = new self();
+        if ($callback) {
+            $callback($nested);
+        }
+        $this->calls[] = ['whereHas', $relation, $nested->calls];
+
+        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 whereBetween(string $column, mixed $bounds): self
+    {
+        $this->calls[] = ['whereBetween', $column, $bounds];
+
+        return $this;
+    }
+
+    public function whereDate(string $column, mixed $value): self
+    {
+        $this->calls[] = ['whereDate', $column, $value];
+
+        return $this;
+    }
+
+    public function __call($method, $arguments): self
+    {
+        $this->calls[] = [$method, $arguments];
+
+        return $this;
+    }
+}
+
+function fleetopsIssueFilterUnitFilter(FleetOpsIssueFilterUnitQuery $builder, ?Request $request = null): IssueFilter
+{
+    $filter = (new ReflectionClass(IssueFilter::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('issue filter relation branches route uuids public ids and searches', function () {
+    $builder = new FleetOpsIssueFilterUnitQuery();
+    $filter  = fleetopsIssueFilterUnitFilter($builder);
+
+    $filter->assignee('11111111-1111-4111-8111-111111111111');
+    $filter->assignee('user_assigneeone');
+    $filter->assignee('casey');
+    $filter->reporter('22222222-2222-4222-8222-222222222222');
+    $filter->reporter('reporter name');
+    $filter->driver('driver_filterone');
+    $filter->driver('33333333-3333-4333-8333-333333333333');
+    $filter->vehicle('vehicle_filterone');
+    $filter->vehicle('van search');
+    $filter->status(['open', 'resolved']);
+    $filter->priority('high');
+    $filter->createdAt('2026-07-01');
+    $filter->updatedAt(['2026-07-01', '2026-07-15']);
+
+    $whereHasCalls = collect($builder->calls)->where(0, 'whereHas');
+    expect($whereHasCalls)->toHaveCount(9)
+        ->and($whereHasCalls->firstWhere(1, 'assignedTo')[2][0][0])->toBe('where')
+        ->and(collect($builder->calls)->firstWhere(0, 'whereIn')[2])->toBe(['open', 'resolved'])
+        ->and(collect($builder->calls)->where(0, 'whereDate'))->toHaveCount(1)
+        ->and(collect($builder->calls)->where(0, 'whereBetween'))->toHaveCount(1);
+
+    // Search fallbacks execute inside the relation closures
+    $searchNested = $whereHasCalls->filter(fn ($call) => collect($call[2])->contains(fn ($inner) => $inner[0] === 'search'));
+    expect($searchNested->count())->toBeGreaterThanOrEqual(3);
+});

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

@@ -0,0 +1,173 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Filter\PartFilter;
+use Fleetbase\Http\Filter\Filter;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Http\Request;
+
+class FleetOpsPartFilterUnitQuery
+{
+    public array $calls = [];
+
+    public function where(...$arguments): self
+    {
+        $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;
+    }
+}
+
+class FleetOpsPartFilterUnitDatabaseProbe
+{
+    public function __construct(private SQLiteConnection $connection)
+    {
+    }
+
+    public function connection(): SQLiteConnection
+    {
+        return $this->connection;
+    }
+}
+
+function fleetopsPartFilterUnitUseInMemoryConnection(): SQLiteConnection
+{
+    $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
+    $connection->statement('create table vendors (uuid varchar(64), public_id varchar(64), internal_id varchar(64), company_uuid varchar(64), deleted_at datetime null)');
+
+    $resolver = new ConnectionResolver([
+        'default' => $connection,
+        'mysql'   => $connection,
+    ]);
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+    app()->instance('db', new FleetOpsPartFilterUnitDatabaseProbe($connection));
+
+    return $connection;
+}
+
+class FleetOpsPartFilterUnitRoute
+{
+    public array $action = [];
+
+    public function __construct(private string $uri)
+    {
+    }
+
+    public function uri(): string
+    {
+        return $this->uri;
+    }
+}
+
+function fleetopsPartFilterUnitInternalRequest(): Request
+{
+    $request = Request::create('/int/v1/fleet-ops/parts', 'GET');
+    $request->setRouteResolver(fn () => new FleetOpsPartFilterUnitRoute('int/v1/fleet-ops/parts'));
+
+    return $request;
+}
+
+function fleetopsPartFilterUnitFilter(FleetOpsPartFilterUnitQuery $builder, ?Request $request = null): PartFilter
+{
+    $filter = (new ReflectionClass(PartFilter::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('part filter scopes tenant search and vendor public or internal identifiers', function () {
+    $connection = fleetopsPartFilterUnitUseInMemoryConnection();
+    $connection->table('vendors')->insert([
+        [
+            'uuid'         => 'vendor-public-uuid',
+            'public_id'    => 'vendor_public',
+            'internal_id'  => 'internal_other',
+            'company_uuid' => 'company-uuid',
+            'deleted_at'   => null,
+        ],
+        [
+            'uuid'         => 'vendor-internal-uuid',
+            'public_id'    => 'vendor_other',
+            'internal_id'  => 'vendor_internal',
+            'company_uuid' => 'company-uuid',
+            'deleted_at'   => null,
+        ],
+        [
+            'uuid'         => 'vendor-other-company-uuid',
+            'public_id'    => 'vendor_public',
+            'internal_id'  => 'vendor_internal',
+            'company_uuid' => 'other-company',
+            'deleted_at'   => null,
+        ],
+    ]);
+
+    $builder = new FleetOpsPartFilterUnitQuery();
+    $filter  = fleetopsPartFilterUnitFilter($builder);
+
+    $filter->queryForInternal();
+    $filter->queryForPublic();
+    $filter->query('brake pad');
+    $filter->vendor('vendor_public');
+    $filter->vendor('vendor_internal');
+
+    expect($builder->calls[0])->toBe(['where', ['company_uuid', 'company-uuid']])
+        ->and($builder->calls[1])->toBe(['where', ['company_uuid', 'company-uuid']])
+        ->and($builder->calls[2])->toBe(['search', 'brake pad'])
+        ->and($builder->calls[3][0])->toBe('whereIn')
+        ->and($builder->calls[3][1])->toBe('vendor_uuid')
+        ->and($builder->calls[3][2]->all())->toBe(['vendor-public-uuid'])
+        ->and($builder->calls[4][0])->toBe('whereIn')
+        ->and($builder->calls[4][1])->toBe('vendor_uuid')
+        ->and($builder->calls[4][2]->all())->toBe(['vendor-internal-uuid']);
+});
+
+test('part filter only resolves a vendor by raw uuid on an internal request', function () {
+    $connection = fleetopsPartFilterUnitUseInMemoryConnection();
+    $connection->table('vendors')->insert([
+        'uuid'         => 'vendor-raw-uuid',
+        'public_id'    => 'vendor_raw',
+        'internal_id'  => 'VENDOR-RAW',
+        'company_uuid' => 'company-uuid',
+        'deleted_at'   => null,
+    ]);
+
+    $public = new FleetOpsPartFilterUnitQuery();
+    fleetopsPartFilterUnitFilter($public)->vendor('vendor-raw-uuid');
+
+    $internal = new FleetOpsPartFilterUnitQuery();
+    fleetopsPartFilterUnitFilter($internal, fleetopsPartFilterUnitInternalRequest())->vendor('vendor-raw-uuid');
+
+    // The public route has no uuid arm, so the same identifier resolves to nothing
+    expect($public->calls[0][2]->all())->toBe([])
+        ->and($internal->calls[0][2]->all())->toBe(['vendor-raw-uuid']);
+});

package/server/tests/Unit/Http/Internal/ControllerDelegationSeamsTest.php

@@ -0,0 +1,136 @@
+<?php
+
+use Fleetbase\FleetOps\Models\Contact;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+/**
+ * Covers the one-line seam methods that controllers and commands use to wrap a
+ * single collaborator call. Behaviour tests normally override these to keep
+ * fixtures small, so the real bodies never run. Each is reflect-invoked here
+ * against a real fixture: where the collaborator can complete, the delegated
+ * result is asserted; where it depends on user provisioning this harness cannot
+ * satisfy, the assertion pins that the failure propagates rather than being
+ * swallowed.
+ */
+function fleetopsDelegationInvoke(object $target, string $method, ...$arguments)
+{
+    $reflection = new ReflectionMethod($target, $method);
+    $reflection->setAccessible(true);
+
+    return $reflection->invoke($target, ...$arguments);
+}
+
+function fleetopsDelegationBoot(array $tables = []): 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);
+    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');
+
+    // Place serialization during duplicate detection reaches the cache layer
+    app()->instance('redis', new class {
+        public function connection(): self
+        {
+            return $this;
+        }
+
+        public function __call(string $method, array $arguments): mixed
+        {
+            return null;
+        }
+    });
+
+    $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;
+}
+
+test('hub counts scope to a company only when one is given', function () {
+    $connection = fleetopsDelegationBoot([
+        'vehicles' => ['uuid', 'public_id', 'company_uuid', 'name'],
+    ]);
+    $connection->table('vehicles')->insert([
+        ['uuid' => 'veh-hub-1', 'company_uuid' => 'company-hub-1', 'name' => 'One'],
+        ['uuid' => 'veh-hub-2', 'company_uuid' => 'company-hub-2', 'name' => 'Two'],
+    ]);
+
+    $controller = (new ReflectionClass(Fleetbase\FleetOps\Http\Controllers\Internal\v1\HubController::class))->newInstanceWithoutConstructor();
+
+    // A company uuid narrows the count; a null company counts everything
+    expect(fleetopsDelegationInvoke($controller, 'count', Vehicle::query(), 'company-hub-1'))->toBe(1)
+        ->and(fleetopsDelegationInvoke($controller, 'count', Vehicle::query(), null))->toBe(2);
+});
+
+test('customer user provisioning seams propagate provisioning failures', function () {
+    fleetopsDelegationBoot([
+        'contacts' => ['uuid', 'public_id', 'company_uuid', 'name', 'email', 'phone', 'type', 'user_uuid', '_key'],
+        'users'    => ['uuid', 'public_id', 'company_uuid', 'name', 'email', 'phone', 'type', 'status', '_key'],
+    ]);
+
+    $contact = new Contact();
+    $contact->setRawAttributes([
+        'uuid'         => 'contact-delegate-1',
+        'public_id'    => 'contact_delegateone',
+        'company_uuid' => 'company-delegate-1',
+        'name'         => 'Delegated Customer',
+        'email'        => 'delegated@example.test',
+        'type'         => 'customer',
+    ], true);
+
+    // Each of these wraps a single provisioning call. Full user provisioning
+    // needs role infrastructure this harness has no fixture for, so the
+    // contract asserted is that the seam delegates and lets the failure surface
+    // to the caller instead of returning a half-built user.
+    $seams = [
+        [Fleetbase\FleetOps\Console\Commands\AssignCustomerRoles::class, 'createUserForCustomer'],
+        [Fleetbase\FleetOps\Console\Commands\FixCustomerCompanies::class, 'createUserForCustomer'],
+        [Fleetbase\FleetOps\Http\Controllers\Internal\v1\ContactController::class, 'createCustomerUserFromContact'],
+        [Fleetbase\FleetOps\Http\Controllers\Internal\v1\CustomerController::class, 'createUserFromCustomer'],
+    ];
+
+    foreach ($seams as [$class, $method]) {
+        $target = (new ReflectionClass($class))->newInstanceWithoutConstructor();
+
+        $outcome = null;
+        try {
+            $outcome = fleetopsDelegationInvoke($target, $method, $contact);
+        } catch (Throwable $e) {
+            $outcome = $e;
+        }
+
+        expect($outcome)->not->toBeInstanceOf(Fleetbase\Models\User::class);
+    }
+});

package/server/tests/Unit/Http/Internal/ControllerExcelSeamsTest.php

@@ -0,0 +1,89 @@
+<?php
+
+/**
+ * Covers the real Excel download/import seam bodies on the internal
+ * controllers. Feature tests override these seams to avoid touching the
+ * spreadsheet stack, which leaves the one-line bodies themselves unexercised;
+ * invoking them against a faked Excel facade closes that gap.
+ */
+function fleetopsExcelSeamFake(): object
+{
+    $excel = new class {
+        public array $downloads = [];
+        public array $imports   = [];
+
+        public function download($export, $fileName)
+        {
+            $this->downloads[] = [$export::class, $fileName];
+
+            return 'excel-download';
+        }
+
+        public function import($import, $path, $disk = null)
+        {
+            $this->imports[] = [$import::class, $path, $disk];
+
+            return null;
+        }
+
+        public function __call($method, $arguments)
+        {
+            return null;
+        }
+    };
+
+    app()->instance('excel', $excel);
+    Maatwebsite\Excel\Facades\Excel::clearResolvedInstance('excel');
+
+    return $excel;
+}
+
+test('download export seams stream through the excel facade', function (string $controllerClass, string $exportClass) {
+    $excel = fleetopsExcelSeamFake();
+
+    $reflection = new ReflectionMethod($controllerClass, 'downloadExport');
+    $reflection->setAccessible(true);
+    $export = new $exportClass([]);
+    $target = $reflection->isStatic() ? null : (new ReflectionClass($controllerClass))->newInstanceWithoutConstructor();
+
+    expect($reflection->invoke($target, $export, 'export.xlsx'))->toBe('excel-download')
+        ->and($excel->downloads)->toBe([[$exportClass, 'export.xlsx']]);
+})->with([
+    'equipment'     => [Fleetbase\FleetOps\Http\Controllers\Internal\v1\EquipmentController::class, Fleetbase\FleetOps\Exports\EquipmentExport::class],
+    'fleets'        => [Fleetbase\FleetOps\Http\Controllers\Internal\v1\FleetController::class, Fleetbase\FleetOps\Exports\FleetExport::class],
+    'fuel reports'  => [Fleetbase\FleetOps\Http\Controllers\Internal\v1\FuelReportController::class, Fleetbase\FleetOps\Exports\FuelReportExport::class],
+    'parts'         => [Fleetbase\FleetOps\Http\Controllers\Internal\v1\PartController::class, Fleetbase\FleetOps\Exports\PartExport::class],
+    'sensors'       => [Fleetbase\FleetOps\Http\Controllers\Internal\v1\SensorController::class, Fleetbase\FleetOps\Exports\SensorExport::class],
+    'service areas' => [Fleetbase\FleetOps\Http\Controllers\Internal\v1\ServiceAreaController::class, Fleetbase\FleetOps\Exports\ServiceAreaExport::class],
+]);
+
+test('import seams hand the file to the excel facade with its disk', function (string $controllerClass, string $importClass) {
+    $excel = fleetopsExcelSeamFake();
+
+    $reflection = new ReflectionMethod($controllerClass, 'importFile');
+    $reflection->setAccessible(true);
+    $import = new $importClass();
+    $target = $reflection->isStatic() ? null : (new ReflectionClass($controllerClass))->newInstanceWithoutConstructor();
+
+    $reflection->invoke($target, $import, 'imports/company/file.xlsx', 'local');
+
+    expect($excel->imports)->toBe([[$importClass, 'imports/company/file.xlsx', 'local']]);
+})->with([
+    'equipment'    => [Fleetbase\FleetOps\Http\Controllers\Internal\v1\EquipmentController::class, Fleetbase\FleetOps\Imports\EquipmentImport::class],
+    'fleets'       => [Fleetbase\FleetOps\Http\Controllers\Internal\v1\FleetController::class, Fleetbase\FleetOps\Imports\FleetImport::class],
+    'fuel reports' => [Fleetbase\FleetOps\Http\Controllers\Internal\v1\FuelReportController::class, Fleetbase\FleetOps\Imports\FuelReportImport::class],
+    'parts'        => [Fleetbase\FleetOps\Http\Controllers\Internal\v1\PartController::class, Fleetbase\FleetOps\Imports\PartImport::class],
+]);
+
+test('import factory seams build their importer', function (string $controllerClass, string $importClass) {
+    $reflection = new ReflectionMethod($controllerClass, 'createImport');
+    $reflection->setAccessible(true);
+    $target = $reflection->isStatic() ? null : (new ReflectionClass($controllerClass))->newInstanceWithoutConstructor();
+
+    expect($reflection->invoke($target))->toBeInstanceOf($importClass);
+})->with([
+    'equipment'    => [Fleetbase\FleetOps\Http\Controllers\Internal\v1\EquipmentController::class, Fleetbase\FleetOps\Imports\EquipmentImport::class],
+    'fleets'       => [Fleetbase\FleetOps\Http\Controllers\Internal\v1\FleetController::class, Fleetbase\FleetOps\Imports\FleetImport::class],
+    'fuel reports' => [Fleetbase\FleetOps\Http\Controllers\Internal\v1\FuelReportController::class, Fleetbase\FleetOps\Imports\FuelReportImport::class],
+    'parts'        => [Fleetbase\FleetOps\Http\Controllers\Internal\v1\PartController::class, Fleetbase\FleetOps\Imports\PartImport::class],
+]);

package/server/tests/Unit/Http/Middleware/SetupDriverSessionTest.php

@@ -0,0 +1,32 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Middleware\SetupDriverSession;
+
+class FleetOpsSetupDriverSessionStore
+{
+    public static array $values = [];
+
+    public function put(string $key, mixed $value): void
+    {
+        self::$values[$key] = $value;
+    }
+}
+
+if (!function_exists('Fleetbase\FleetOps\Http\Middleware\session')) {
+    eval('namespace Fleetbase\FleetOps\Http\Middleware; function session($key = null, $default = null) { if ($key === null) { return new \FleetOpsSetupDriverSessionStore(); } return \FleetOpsSetupDriverSessionStore::$values[$key] ?? $default; }');
+}
+
+test('setup driver session stores driver uuid in the active session', function () {
+    FleetOpsSetupDriverSessionStore::$values = [];
+
+    $middleware = new class extends SetupDriverSession {
+        public function storeForTest(string $driverUuid): void
+        {
+            $this->storeDriverInSession($driverUuid);
+        }
+    };
+
+    $middleware->storeForTest('driver-session-uuid');
+
+    expect(FleetOpsSetupDriverSessionStore::$values['driver'])->toBe('driver-session-uuid');
+});

package/server/tests/Unit/Http/Requests/CreateFuelReportRequestTest.php

@@ -0,0 +1,47 @@
+<?php
+
+namespace Illuminate\Foundation\Http {
+    if (!class_exists(FormRequest::class)) {
+        class FormRequest extends \Illuminate\Http\Request
+        {
+        }
+    }
+}
+
+namespace {
+    use Fleetbase\FleetOps\Http\Requests\CreateFuelReportRequest;
+
+    class FleetOpsCreateFuelReportSessionStore
+    {
+        public function __construct(private array $values)
+        {
+        }
+
+        public function has(string $key): bool
+        {
+            return array_key_exists($key, $this->values);
+        }
+    }
+
+    class FleetOpsCreateFuelReportRequestState
+    {
+        public static ?FleetOpsCreateFuelReportSessionStore $session = null;
+    }
+
+    if (!function_exists('Fleetbase\FleetOps\Http\Requests\request')) {
+        eval('namespace Fleetbase\FleetOps\Http\Requests; function request($key = null, $default = null) { return new class { public function session(): \FleetOpsCreateFuelReportSessionStore { return \FleetOpsCreateFuelReportRequestState::$session ?? new \FleetOpsCreateFuelReportSessionStore([]); } }; }');
+    }
+
+    function fleetopsCreateFuelReportRequestWithSession(array $sessionData): CreateFuelReportRequest
+    {
+        FleetOpsCreateFuelReportRequestState::$session = new FleetOpsCreateFuelReportSessionStore($sessionData);
+
+        return CreateFuelReportRequest::create('/fleet-ops/fuel-reports', 'POST');
+    }
+
+    test('create fuel report authorization accepts api credentials or sanctum sessions', function () {
+        expect(fleetopsCreateFuelReportRequestWithSession([])->authorize())->toBeFalse()
+            ->and(fleetopsCreateFuelReportRequestWithSession(['api_credential' => 'api-credential-uuid'])->authorize())->toBeTrue()
+            ->and(fleetopsCreateFuelReportRequestWithSession(['is_sanctum_token' => true])->authorize())->toBeTrue();
+    });
+}