@fleetbase/fleetops-engine 0.6.58 → 0.6.59

package/server/tests/FlowResourceTest.php

@@ -0,0 +1,295 @@
+<?php
+
+use Fleetbase\FleetOps\Flow\Activity;
+use Fleetbase\FleetOps\Flow\Condition;
+use Fleetbase\FleetOps\Flow\Event;
+use Fleetbase\FleetOps\Flow\Flow;
+use Fleetbase\FleetOps\Flow\FlowResource;
+use Fleetbase\FleetOps\Flow\Logic;
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Models\Waypoint;
+
+if (!Illuminate\Support\Str::hasMacro('humanize')) {
+    Illuminate\Support\Str::macro('humanize', fn ($value, $uppercase = true) => str_replace('_', ' ', Illuminate\Support\Str::snake((string) $value)));
+}
+
+class FlowTestOrder extends Order
+{
+    public array $dynamicValues          = [];
+    public array $completedActivityCodes = [];
+
+    public function resolveDynamicValue(string $value)
+    {
+        return $this->dynamicValues[$value] ?? $value;
+    }
+
+    public function hasCompletedActivity(Activity $activity): bool
+    {
+        return in_array($activity->code, $this->completedActivityCodes, true);
+    }
+}
+
+function flowTestOrder(array $dynamicValues = [], array $completedActivityCodes = []): FlowTestOrder
+{
+    $order                         = new FlowTestOrder();
+    $order->dynamicValues          = $dynamicValues;
+    $order->completedActivityCodes = $completedActivityCodes;
+
+    return $order;
+}
+
+function flowFixture(): array
+{
+    return [
+        'activities' => [
+            [
+                'code'       => 'created',
+                'activities' => ['ready'],
+            ],
+            [
+                'code'       => 'ready',
+                'complete'   => false,
+                'events'     => ['order_ready'],
+                'activities' => ['completed'],
+                'logic'      => [
+                    [
+                        'type'       => 'and',
+                        'conditions' => [
+                            ['field' => 'status', 'operator' => 'equal', 'value' => 'ready'],
+                        ],
+                    ],
+                ],
+            ],
+            [
+                'code'       => 'completed',
+                'complete'   => true,
+                'activities' => [],
+                'logic'      => [
+                    [
+                        'type'       => 'if',
+                        'conditions' => [
+                            ['field' => 'status', 'operator' => 'equal', 'value' => 'completed'],
+                        ],
+                    ],
+                ],
+            ],
+        ],
+        'created' => [
+            'code'       => 'created',
+            'activities' => ['ready'],
+        ],
+        'ready' => [
+            'code'       => 'ready',
+            'complete'   => false,
+            'events'     => ['order_ready'],
+            'activities' => ['completed'],
+            'logic'      => [
+                [
+                    'type'       => 'and',
+                    'conditions' => [
+                        ['field' => 'status', 'operator' => 'equal', 'value' => 'ready'],
+                    ],
+                ],
+            ],
+        ],
+        'completed' => [
+            'code'       => 'completed',
+            'complete'   => true,
+            'activities' => [],
+            'logic'      => [
+                [
+                    'type'       => 'if',
+                    'conditions' => [
+                        ['field' => 'status', 'operator' => 'equal', 'value' => 'completed'],
+                    ],
+                ],
+            ],
+        ],
+    ];
+}
+
+test('flow resources expose mutable attributes and json serialization', function () {
+    $resource = new FlowResource(['code' => 'created']);
+    $returned = $resource->set('status', 'Created');
+
+    expect($returned)->toBe($resource)
+        ->and($resource->code)->toBe('created')
+        ->and(isset($resource->status))->toBeTrue()
+        ->and($resource->get('missing', 'fallback'))->toBe('fallback')
+        ->and($resource->serialize())->toBe(['code' => 'created', 'status' => 'Created'])
+        ->and($resource->toArray())->toBe($resource->serialize())
+        ->and(json_decode($resource->toJson(), true))->toBe($resource->serialize())
+        ->and($resource->jsonSerialize())->toBe($resource->serialize());
+});
+
+test('flow locates keyed activities and iterates configured activity list', function () {
+    $flow = new Flow(flowFixture());
+
+    expect(iterator_to_array($flow))->toHaveCount(3)
+        ->and($flow->getActivity('ready'))->toBeInstanceOf(Activity::class)
+        ->and($flow->getActivity('ready')?->code)->toBe('ready')
+        ->and($flow->getActivity('missing'))->toBeNull()
+        ->and(Flow::isActivity($flow->getActivity('ready')))->toBeTrue()
+        ->and(Flow::isActivity(new stdClass()))->toBeFalse();
+});
+
+test('flow conditions evaluate comparison operators and reject unknown operators', function () {
+    $order = flowTestOrder([
+        'status'   => 'Ready',
+        'priority' => 3,
+        'notes'    => 'deliver fragile parcel',
+    ]);
+
+    expect((new Condition(['field' => 'status', 'operator' => 'equal', 'value' => 'ready']))->eval($order))->toBeTrue()
+        ->and((new Condition(['field' => 'status', 'operator' => 'notEqual', 'value' => 'completed']))->eval($order))->toBeTrue()
+        ->and((new Condition(['field' => 'priority', 'operator' => 'greaterThan', 'value' => 2]))->eval($order))->toBeTrue()
+        ->and((new Condition(['field' => 'priority', 'operator' => 'lessThanOrEqual', 'value' => 3]))->eval($order))->toBeTrue()
+        ->and((new Condition(['field' => 'notes', 'operator' => 'contains', 'value' => 'deliver fragile parcel today']))->eval($order))->toBeTrue()
+        ->and((new Condition(['field' => 'notes', 'operator' => 'beginsWith', 'value' => 'deliver fragile parcel']))->eval($order))->toBeTrue()
+        ->and((new Condition(['field' => 'notes', 'operator' => 'endsWith', 'value' => 'today deliver fragile parcel']))->eval($order))->toBeTrue();
+
+    expect(fn () => (new Condition(['field' => 'status', 'operator' => 'between', 'value' => []]))->eval($order))
+        ->toThrow(Exception::class, 'Unknown operator: between');
+
+    // Remaining operator arms: existence, array membership, boolean logic
+    // and the strict lower-than comparison
+    expect((new Condition(['field' => 'status', 'operator' => 'exists', 'value' => null]))->eval($order))->toBeTrue()
+        ->and((new Condition(['field' => 'status', 'operator' => 'in', 'value' => ['ready']]))->eval($order))->toBeFalse()
+        ->and((new Condition(['field' => 'status', 'operator' => 'notIn', 'value' => ['ready']]))->eval($order))->toBeFalse()
+        ->and((new Condition(['field' => 'status', 'operator' => 'and', 'value' => true]))->eval($order))->toBeTrue()
+        ->and((new Condition(['field' => 'status', 'operator' => 'or', 'value' => false]))->eval($order))->toBeTrue()
+        ->and((new Condition(['field' => 'status', 'operator' => 'not', 'value' => null]))->eval($order))->toBeFalse()
+        ->and((new Condition(['field' => 'priority', 'operator' => 'lessThan', 'value' => 9]))->eval($order))->toBeTrue();
+});
+
+test('flow logic combines conditions with and or not and if semantics', function () {
+    $readyOrder = flowTestOrder(['status' => 'ready', 'priority' => 5]);
+    $heldOrder  = flowTestOrder(['status' => 'held', 'priority' => 1]);
+
+    expect((new Logic([
+        'type'       => 'and',
+        'conditions' => [
+            ['field' => 'status', 'operator' => 'equal', 'value' => 'ready'],
+            ['field' => 'priority', 'operator' => 'greaterThanOrEqual', 'value' => 5],
+        ],
+    ]))->passes($readyOrder))->toBeTrue()
+        ->and((new Logic([
+            'type'       => 'or',
+            'conditions' => [
+                ['field' => 'status', 'operator' => 'equal', 'value' => 'ready'],
+                ['field' => 'priority', 'operator' => 'greaterThan', 'value' => 5],
+            ],
+        ]))->passes($readyOrder))->toBeTrue()
+        ->and((new Logic([
+            'type'       => 'not',
+            'conditions' => [
+                ['field' => 'status', 'operator' => 'equal', 'value' => 'ready'],
+            ],
+        ]))->passes($heldOrder))->toBeTrue()
+        ->and((new Logic([
+            'type'       => 'if',
+            'conditions' => [
+                ['field' => 'status', 'operator' => 'equal', 'value' => 'ready'],
+            ],
+        ]))->passes($readyOrder))->toBeTrue();
+
+    expect(fn () => (new Logic(['type' => 'xor']))->passes($readyOrder))
+        ->toThrow(Exception::class, 'Unknown logic type: xor');
+});
+
+test('activities expose events child traversal next previous and completion state', function () {
+    $flow     = flowFixture();
+    $activity = new Activity($flow['ready'], $flow);
+
+    expect($activity->logic)->toHaveCount(1)
+        ->and($activity->events[0])->toBeInstanceOf(Event::class)
+        ->and($activity->children())->toHaveCount(1)
+        ->and($activity->hasChildActivity('completed'))->toBeTrue()
+        ->and($activity->hasChildActivity('missing'))->toBeFalse()
+        ->and($activity->is('ready'))->toBeTrue()
+        ->and($activity->complete())->toBeFalse()
+        ->and($activity->completesOrder())->toBeFalse()
+        ->and($activity->isCompleted(flowTestOrder([], ['ready'])))->toBeTrue()
+        ->and($activity->getNext(flowTestOrder(['status' => 'completed']))->first()?->code)->toBe('completed')
+        ->and($activity->getNext(flowTestOrder(['status' => 'ready'])))->toHaveCount(0)
+        ->and($activity->getPrevious()->first()?->code)->toBe('created');
+});
+
+test('flow events resolve names mutate context and no-op unresolved fires', function () {
+    $order    = flowTestOrder();
+    $activity = new Activity(['code' => 'ready'], flowFixture());
+    $waypoint = new Waypoint();
+    $event    = new Event('order_ready');
+
+    expect($event->resolve())->toBe('\\Fleetbase\\FleetOps\\Events\\OrderReady')
+        ->and($event->setOrder($order))->toBe($event)
+        ->and($event->setActivity($activity))->toBe($event)
+        ->and($event->setWaypoint($waypoint))->toBe($event)
+        ->and($event->order)->toBe($order)
+        ->and($event->activity)->toBe($activity)
+        ->and($event->waypoint)->toBe($waypoint)
+        ->and((new Event('missing_event_name'))->resolve())->toBeNull();
+
+    $unresolved = new Event('missing_event_name');
+    $unresolved->fire($order, $activity, $waypoint);
+
+    expect($unresolved->order)->toBe($order)
+        ->and($unresolved->activity)->toBe($activity)
+        ->and($unresolved->waypoint)->toBe($waypoint);
+});
+
+test('firing an activity passes the order and waypoint to each of its events', function () {
+    $order    = flowTestOrder();
+    $waypoint = new Waypoint();
+    // Event names that resolve to no class make the fire a no-op, which keeps
+    // this to the activity's own loop rather than the lifecycle event machinery
+    $activity = new Activity([
+        'code'   => 'ready',
+        'events' => ['missing_event_one', 'missing_event_two'],
+    ], flowFixture());
+
+    $dispatcher = new class {
+        public array $dispatched = [];
+
+        public function dispatch($event, $payload = [], $halt = false)
+        {
+            $this->dispatched[] = $event;
+
+            return [];
+        }
+
+        public function __call($method, $arguments)
+        {
+            return null;
+        }
+    };
+    app()->instance('events', $dispatcher);
+
+    $activity->fireEvents($order, $waypoint);
+
+    expect($activity->events)->toHaveCount(2)
+        ->and($dispatcher->dispatched)->toBe([]);
+
+    app()->forgetInstance('events');
+});
+
+test('activity logic arms evaluate and or not if and unsupported types', function () {
+    $order = flowTestOrder([
+        'status'   => 'ready',
+        'priority' => 3,
+        'notes'    => 'note',
+    ]);
+
+    $makeActivity = fn (array $logic) => new Activity([
+        'code'  => 'conditional',
+        'logic' => $logic,
+    ]);
+
+    expect($makeActivity([['type' => 'and', 'conditions' => [['field' => 'status', 'operator' => 'equal', 'value' => 'ready']]]])->passes($order))->toBeTrue()
+        ->and($makeActivity([['type' => 'or', 'conditions' => [['field' => 'status', 'operator' => 'equal', 'value' => 'nope'], ['field' => 'status', 'operator' => 'equal', 'value' => 'ready']]]])->passes($order))->toBeTrue()
+        ->and($makeActivity([['type' => 'not', 'conditions' => [['field' => 'status', 'operator' => 'equal', 'value' => 'canceled']]]])->passes($order))->toBeTrue()
+        ->and($makeActivity([['type' => 'if', 'conditions' => [['field' => 'status', 'operator' => 'equal', 'value' => 'ready']]]])->passes($order))->toBeTrue();
+
+    expect(fn () => $makeActivity([['type' => 'xor', 'conditions' => [['field' => 'status', 'operator' => 'equal', 'value' => 'ready']]]])->passes($order))
+        ->toThrow(Exception::class, "Unsupported logic type 'xor' provided.");
+});

package/server/tests/FuelProviderConnectionControllerContractsTest.php

@@ -0,0 +1,303 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\FuelProviderConnectionController;
+use Fleetbase\FleetOps\Models\FuelProviderConnection;
+use Fleetbase\FleetOps\Models\FuelProviderSyncRun;
+use Fleetbase\FleetOps\Support\FuelProviders\FuelProviderService;
+use Illuminate\Http\Request;
+use Illuminate\Support\Carbon;
+use Illuminate\Support\Collection;
+use Illuminate\Validation\ValidationException;
+
+class FleetOpsFuelProviderConnectionControllerProbe extends FuelProviderConnectionController
+{
+    public ?FuelProviderConnection $connection = null;
+
+    protected function findConnection(string $id): FuelProviderConnection
+    {
+        $this->connection?->setAttribute('lookup_id', $id);
+
+        return $this->connection;
+    }
+}
+
+class FleetOpsFuelProviderConnectionServiceFake extends FuelProviderService
+{
+    public array $credentialTests = [];
+    public array $connectionTests = [];
+    public array $syncRuns        = [];
+    public array $syncs           = [];
+    public Collection $providerDescriptors;
+    public array $credentialResult = ['success' => true, 'message' => 'Credentials accepted.'];
+    public array $connectionResult = ['success' => true, 'message' => 'Connection accepted.'];
+    public array $syncSummary      = ['imported' => 2, 'matched' => 1, 'unmatched' => 1];
+
+    public function __construct()
+    {
+        $this->providerDescriptors = collect([
+            [
+                'key'             => 'petroapp',
+                'name'            => 'PetroApp',
+                'required_fields' => [
+                    ['name' => 'api_token', 'label' => 'API token', 'required' => true],
+                    ['name' => 'region', 'label' => 'Region', 'required' => false],
+                ],
+            ],
+        ]);
+    }
+
+    public function providers(): Collection
+    {
+        return $this->providerDescriptors;
+    }
+
+    public function testCredentials(string $providerKey, array $credentials, string $environment = 'production'): array
+    {
+        $this->credentialTests[] = [$providerKey, $credentials, $environment];
+
+        return $this->credentialResult;
+    }
+
+    public function testConnection(FuelProviderConnection $connection): array
+    {
+        $this->connectionTests[] = $connection;
+
+        return $this->connectionResult;
+    }
+
+    public function createSyncRun(FuelProviderConnection $connection, ?Carbon $from = null, ?Carbon $to = null, string $status = 'queued'): FuelProviderSyncRun
+    {
+        $syncRun = new FleetOpsFuelProviderSyncRunFake();
+        $syncRun->setRawAttributes([
+            'uuid'   => 'sync-run-uuid',
+            'status' => $status,
+            'from'   => $from,
+            'to'     => $to,
+        ]);
+
+        $this->syncRuns[] = [$connection, $from, $to, $status, $syncRun];
+
+        return $syncRun;
+    }
+
+    public function syncTransactions(FuelProviderConnection $connection, ?Carbon $from = null, ?Carbon $to = null, array $options = [], ?FuelProviderSyncRun $syncRun = null): array
+    {
+        $this->syncs[] = [$connection, $from, $to, $options, $syncRun];
+
+        return $this->syncSummary;
+    }
+}
+
+class FleetOpsFuelProviderConnectionFake extends FuelProviderConnection
+{
+    public function toArray(): array
+    {
+        return $this->getAttributes();
+    }
+}
+
+class FleetOpsFuelProviderSyncRunFake extends FuelProviderSyncRun
+{
+    public bool $freshForTest = false;
+
+    public function fresh($with = [])
+    {
+        $this->freshForTest = true;
+
+        return $this;
+    }
+}
+
+function fleetopsFuelProviderConnectionController(FleetOpsFuelProviderConnectionServiceFake $service): FleetOpsFuelProviderConnectionControllerProbe
+{
+    return new FleetOpsFuelProviderConnectionControllerProbe($service);
+}
+
+test('fuel provider connection controller lists providers and validates connection input', function () {
+    session(['company' => 'company-uuid']);
+
+    $service    = new FleetOpsFuelProviderConnectionServiceFake();
+    $controller = fleetopsFuelProviderConnectionController($service);
+
+    expect($controller->providers()->getData(true))->toBe($service->providers()->all());
+
+    $missingProvider = [];
+    expect(fn () => $controller->onBeforeCreate(new Request(), $missingProvider))
+        ->toThrow(ValidationException::class);
+
+    $unknownProvider = ['provider' => 'missing', 'credentials' => ['api_token' => 'token-1']];
+    expect(fn () => $controller->onBeforeCreate(new Request(), $unknownProvider))
+        ->toThrow(ValidationException::class);
+
+    $missingRequiredCredential = ['provider' => 'petroapp', 'credentials' => []];
+    expect(fn () => $controller->onBeforeCreate(new Request(), $missingRequiredCredential))
+        ->toThrow(ValidationException::class);
+
+    $input = [
+        'provider'      => 'petroapp',
+        'credentials'   => ['api_token' => 'token-1'],
+        'sync_settings' => ['window_days' => 14],
+    ];
+
+    $controller->onBeforeCreate(new Request(), $input);
+
+    expect($input['company_uuid'])->toBe('company-uuid')
+        ->and($input['environment'])->toBe('production')
+        ->and($input['status'])->toBe('configured')
+        ->and($input['sync_settings']['window_days'])->toBe(14)
+        ->and($input['sync_settings']['auto_create_fuel_reports'])->toBeTrue()
+        ->and($input['sync_settings']['matching_order'])->toBe([
+            'plate_number',
+            'internal_id',
+            'vin',
+            'serial_number',
+            'call_sign',
+            'fuel_card_number',
+            'trip_number',
+        ]);
+});
+
+test('fuel provider connection controller preserves active status while normalizing updates', function () {
+    session(['company' => 'company-uuid']);
+
+    $service    = new FleetOpsFuelProviderConnectionServiceFake();
+    $controller = fleetopsFuelProviderConnectionController($service);
+
+    $connection = new FleetOpsFuelProviderConnectionFake();
+    $connection->setRawAttributes([
+        'provider'    => 'petroapp',
+        'status'      => 'active',
+        'credentials' => ['api_token' => 'existing-token'],
+    ]);
+
+    $input = [
+        'credentials' => ['api_token' => 'updated-token'],
+    ];
+
+    $controller->onBeforeUpdate(new Request(), $connection, $input);
+
+    expect($input)->toMatchArray([
+        'company_uuid' => 'company-uuid',
+        'environment'  => 'production',
+        'status'       => 'active',
+    ]);
+});
+
+test('fuel provider connection controller tests credentials and existing connections', function () {
+    $service    = new FleetOpsFuelProviderConnectionServiceFake();
+    $controller = fleetopsFuelProviderConnectionController($service);
+
+    $credentialsResponse = $controller->testCredentials(new Request([
+        'credentials' => ['api_token' => 'token-1'],
+        'environment' => 'sandbox',
+    ]), 'petroapp');
+
+    expect($credentialsResponse->getStatusCode())->toBe(200)
+        ->and($credentialsResponse->getData(true))->toBe([
+            'success' => true,
+            'message' => 'Credentials accepted.',
+        ])
+        ->and($service->credentialTests)->toBe([
+            ['petroapp', ['api_token' => 'token-1'], 'sandbox'],
+        ]);
+
+    $service->credentialResult = ['success' => false, 'message' => 'Rejected.'];
+    $rejectedResponse          = $controller->testCredentials(new Request([
+        'credentials' => ['api_token' => 'bad-token'],
+    ]), 'petroapp');
+
+    expect($rejectedResponse->getStatusCode())->toBe(422);
+
+    $connection = new FleetOpsFuelProviderConnectionFake();
+    $connection->setRawAttributes(['uuid' => 'connection-uuid']);
+    $controller->connection = $connection;
+
+    $connectionResponse = $controller->testConnection(new Request(), 'connection-public');
+
+    expect($connectionResponse->getStatusCode())->toBe(200)
+        ->and($connectionResponse->getData(true))->toBe([
+            'success' => true,
+            'message' => 'Connection accepted.',
+        ])
+        ->and($service->connectionTests)->toBe([$connection])
+        ->and($connection->lookup_id)->toBe('connection-public');
+});
+
+test('fuel provider connection controller runs synchronous sync with parsed windows and options', function () {
+    $service    = new FleetOpsFuelProviderConnectionServiceFake();
+    $controller = fleetopsFuelProviderConnectionController($service);
+
+    $connection = new FleetOpsFuelProviderConnectionFake();
+    $connection->setRawAttributes([
+        'uuid'         => 'connection-uuid',
+        'company_uuid' => 'company-uuid',
+        'provider'     => 'petroapp',
+    ]);
+    $controller->connection = $connection;
+
+    $response = $controller->sync(new Request([
+        'async'   => false,
+        'from'    => '2026-07-01',
+        'to'      => '2026-07-10',
+        'options' => ['limit' => 10],
+    ]), 'connection-public');
+
+    expect($response->getStatusCode())->toBe(200)
+        ->and($response->getData(true)['status'])->toBe('ok')
+        ->and($response->getData(true)['summary'])->toBe($service->syncSummary)
+        ->and($service->syncRuns)->toHaveCount(1)
+        ->and($service->syncRuns[0][3])->toBe('running')
+        ->and($service->syncs)->toHaveCount(1)
+        ->and($service->syncs[0][1]->toDateString())->toBe('2026-07-01')
+        ->and($service->syncs[0][2]->toDateString())->toBe('2026-07-10')
+        ->and($service->syncs[0][3])->toBe(['limit' => 10])
+        ->and($service->syncs[0][4])->toBe($service->syncRuns[0][4])
+        ->and($service->syncs[0][4]->freshForTest)->toBeTrue();
+});
+
+test('fuel provider sync queues async runs and finds real connections', function () {
+    // Async syncs queue the job and return a 202 with the queued run
+    $service    = new FleetOpsFuelProviderConnectionServiceFake();
+    $controller = fleetopsFuelProviderConnectionController($service);
+
+    $connection = new FleetOpsFuelProviderConnectionFake();
+    $connection->setRawAttributes([
+        'uuid'         => 'connection-uuid',
+        'company_uuid' => 'company-uuid',
+        'provider'     => 'petroapp',
+    ]);
+    $controller->connection = $connection;
+
+    $response = $controller->sync(new Request([
+        'async' => true,
+        'from'  => '2026-07-01',
+        'to'    => '2026-07-10',
+    ]), 'connection-public');
+
+    expect($response->getStatusCode())->toBe(202)
+        ->and($response->getData(true)['message'])->toBe('Fuel provider sync queued.')
+        ->and($service->syncRuns[0][3])->toBe('queued')
+        ->and($service->syncs)->toHaveCount(0);
+
+    // The real connection lookup scopes by identifier and session company
+    $dbConnection = new Illuminate\Database\SQLiteConnection(new PDO('sqlite::memory:'));
+    $resolver     = new Illuminate\Database\ConnectionResolver(['default' => $dbConnection, 'mysql' => $dbConnection]);
+    $resolver->setDefaultConnection('mysql');
+    Illuminate\Database\Eloquent\Model::setConnectionResolver($resolver);
+    $schema = $dbConnection->getSchemaBuilder();
+    $schema->create('fuel_provider_connections', function ($blueprint) {
+        $blueprint->increments('id');
+        foreach (['uuid', 'public_id', 'company_uuid', 'provider', 'name', 'credentials', 'sync_settings', 'status', 'meta', '_key'] as $column) {
+            $blueprint->string($column)->nullable();
+        }
+        $blueprint->timestamps();
+        $blueprint->timestamp('deleted_at')->nullable();
+    });
+    session(['company' => 'company-real-1']);
+    $dbConnection->table('fuel_provider_connections')->insert(['uuid' => 'fpc-real-1', 'public_id' => 'fuel_provider_connection_real1', 'company_uuid' => 'company-real-1', 'provider' => 'petroapp']);
+
+    $reflection = new ReflectionMethod(FuelProviderConnectionController::class, 'findConnection');
+    $reflection->setAccessible(true);
+    $found = $reflection->invoke(fleetopsFuelProviderConnectionController(new FleetOpsFuelProviderConnectionServiceFake()), 'fuel_provider_connection_real1');
+    expect($found->uuid)->toBe('fpc-real-1');
+});