@fleetbase/fleetops-engine 0.6.58 → 0.6.59

package/server/tests/Unit/Support/OsrmProofAndIssueFilterTest.php

@@ -0,0 +1,247 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\ProofController;
+use Fleetbase\FleetOps\Http\Filter\IssueFilter;
+use Fleetbase\FleetOps\Models\Proof;
+use Fleetbase\FleetOps\Support\OSRM;
+use Fleetbase\Http\Filter\Filter;
+use Fleetbase\LaravelMysqlSpatial\Types\Point;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Cache;
+use Illuminate\Support\Facades\Http;
+
+/**
+ * Covers the OSRM routing client with faked HTTP and cache, the internal
+ * ProofController subject lookup and persistence helpers, and the
+ * IssueFilter relation/date filters against SQLite.
+ */
+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 (!function_exists('Fleetbase\Support\auth')) {
+    eval('namespace Fleetbase\Support; function auth() { return new class { public function user() { return null; } public function id() { return null; } }; }');
+}
+
+class FleetOpsProofControllerProbe extends ProofController
+{
+    public function callHelper(string $method, ...$arguments): mixed
+    {
+        return $this->{$method}(...$arguments);
+    }
+}
+
+class FleetOpsIssueFilterQueryFake
+{
+    public array $calls = [];
+
+    public function whereHas(string $relation, ?Closure $callback = null): self
+    {
+        $nested = new self();
+        if ($callback) {
+            $callback($nested);
+        }
+        $this->calls[] = ['whereHas', $relation, $nested->calls];
+
+        return $this;
+    }
+
+    public function __call($method, $arguments)
+    {
+        $this->calls[] = [$method, $arguments];
+
+        return $this;
+    }
+}
+
+function fleetopsOsrmProofBoot(): 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');
+
+    Http::clearResolvedInstances();
+    app()->forgetInstance(Illuminate\Http\Client\Factory::class);
+
+    Cache::swap(new class {
+        public array $store = [];
+
+        public function has($key)
+        {
+            return array_key_exists($key, $this->store);
+        }
+
+        public function get($key, $default = null)
+        {
+            return $this->store[$key] ?? (is_callable($default) ? $default() : $default);
+        }
+
+        public function put($key, $value, $ttl = null)
+        {
+            $this->store[$key] = $value;
+
+            return true;
+        }
+
+        public function __call($method, $arguments)
+        {
+            return null;
+        }
+    });
+
+    $storageFake = new class {
+        public array $writes = [];
+
+        public function disk($disk = null)
+        {
+            return $this;
+        }
+
+        public function put($path, $contents, $options = [])
+        {
+            $this->writes[] = [$path];
+
+            return true;
+        }
+    };
+    app()->instance('filesystem', $storageFake);
+    Illuminate\Support\Facades\Storage::clearResolvedInstance('filesystem');
+    $GLOBALS['fleetopsProofStorageFake'] = $storageFake;
+
+    $schema = $connection->getSchemaBuilder();
+    $tables = [
+        'orders'    => ['uuid', 'public_id', 'company_uuid', 'status'],
+        'waypoints' => ['uuid', 'public_id', 'company_uuid', 'payload_uuid', 'place_uuid', 'order'],
+        'entities'  => ['uuid', 'public_id', 'company_uuid', 'name'],
+        'proofs'    => ['uuid', 'public_id', 'company_uuid', 'order_uuid', 'subject_uuid', 'subject_type', 'remarks', 'raw_data', 'data', 'file_uuid', '_key'],
+        'files'     => ['uuid', 'public_id', 'company_uuid', 'name', 'original_filename', 'extension', 'content_type', 'path', 'bucket', 'disk', 'size', 'type', 'meta', '_key', 'subject_uuid', 'subject_type', 'uploader_uuid'],
+    ];
+    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;
+}
+
+test('osrm builds routes tables and trips with cached responses', function () {
+    fleetopsOsrmProofBoot();
+    Http::fake(['*' => Http::response(['code' => 'Ok', 'routes' => [['distance' => 1000, 'duration' => 120]], 'waypoints' => []], 200)]);
+
+    $start = new Point(1.30, 103.80);
+    $end   = new Point(1.35, 103.85);
+
+    $route = OSRM::getRoute($start, $end);
+    expect($route)->toBeArray()
+        ->and($route['code'] ?? null)->toBe('Ok');
+
+    // Fewer than two points is rejected
+    expect(fn () => OSRM::getRouteFromPoints([$start]))->toThrow(InvalidArgumentException::class);
+
+    $multi = OSRM::getRouteFromPoints([$start, $end]);
+    expect($multi)->toBeArray();
+
+    // Cached second call short-circuits the HTTP layer
+    $again = OSRM::getRouteFromPoints([$start, $end]);
+    expect($again)->toBeArray();
+
+    expect(OSRM::getNearest($start))->toBeArray()
+        ->and(OSRM::getTable([$start, $end]))->toBeArray()
+        ->and(OSRM::getTrip([$start, $end]))->toBeArray();
+});
+
+test('proof subject lookups resolve by uuid and public id per type', function () {
+    $connection = fleetopsOsrmProofBoot();
+    $connection->table('orders')->insert(['uuid' => 'order-1', 'public_id' => 'order_proof', 'company_uuid' => 'company-1']);
+    $connection->table('waypoints')->insert(['uuid' => 'wp-1', 'public_id' => 'waypoint_proof', 'company_uuid' => 'company-1']);
+    $connection->table('entities')->insert(['uuid' => 'ent-1', 'public_id' => 'entity_proof', 'company_uuid' => 'company-1']);
+
+    $probe = new FleetOpsProofControllerProbe();
+
+    expect($probe->callHelper('findQrSubject', 'order', 'order-1')?->uuid)->toBe('order-1')
+        ->and($probe->callHelper('findQrSubject', 'waypoint', 'wp-1')?->uuid)->toBe('wp-1')
+        ->and($probe->callHelper('findQrSubject', 'entity', 'ent-1')?->uuid)->toBe('ent-1')
+        ->and($probe->callHelper('findQrSubject', 'unknown', 'x'))->toBeNull();
+
+    expect($probe->callHelper('findPublicSubject', 'order', 'order_proof')?->uuid)->toBe('order-1')
+        ->and($probe->callHelper('findPublicSubject', 'waypoint', 'waypoint_proof')?->uuid)->toBe('wp-1')
+        ->and($probe->callHelper('findPublicSubject', 'entity', 'entity_proof')?->uuid)->toBe('ent-1')
+        ->and($probe->callHelper('findPublicSubject', 'unknown', 'x'))->toBeNull();
+
+    $proof = $probe->callHelper('createProof', ['company_uuid' => 'company-1', 'order_uuid' => 'order-1', 'subject_uuid' => 'order-1', 'remarks' => 'Signed']);
+    expect($proof)->toBeInstanceOf(Proof::class)
+        ->and($connection->table('proofs')->count())->toBe(1);
+
+    $probe->callHelper('storeSignature', 'signatures/proof.png', 'binary', 'public');
+    expect($GLOBALS['fleetopsProofStorageFake']->writes)->toHaveCount(1);
+
+    expect($probe->callHelper('jsonResponse', ['status' => 'ok'])->getData(true))->toBe(['status' => 'ok'])
+        ->and($probe->callHelper('errorResponse', 'nope')->getData(true)['error'])->toBe('nope')
+        ->and($probe->callHelper('proofSuccessPayload', $proof))->toBeArray();
+});
+
+test('issue filter builds relation subqueries and date windows', function () {
+    fleetopsOsrmProofBoot();
+
+    $filter = (new ReflectionClass(IssueFilter::class))->newInstanceWithoutConstructor();
+    $query  = new FleetOpsIssueFilterQueryFake();
+    foreach ([
+        'builder' => $query,
+        'session' => new class {
+            public function get(string $key): ?string
+            {
+                return $key === 'company' ? 'company-1' : null;
+            }
+        },
+        'request' => new Request(),
+    ] as $property => $value) {
+        $reflection = new ReflectionProperty(Filter::class, $property);
+        $reflection->setAccessible(true);
+        $reflection->setValue($filter, $value);
+    }
+
+    // uuid, public id, and free-text variants route to different subqueries
+    $filter->assignee('11111111-1111-4111-8111-111111111111');
+    $filter->reporter('user_abc1234');
+    $filter->driver('casey');
+    $filter->vehicle('11111111-1111-4111-8111-111111111111');
+
+    $whereHas = collect($query->calls)->where(0, 'whereHas');
+    expect($whereHas)->toHaveCount(4)
+        ->and($whereHas->pluck(1)->all())->toBe(['assignedTo', 'reportedBy', 'driver', 'vehicle']);
+
+    // Date filters use ranges or single dates
+    $filter->createdAt('2026-07-01,2026-07-31');
+    $filter->updatedAt('2026-07-15');
+
+    expect(collect($query->calls)->where(0, 'whereBetween'))->toHaveCount(1)
+        ->and(collect($query->calls)->where(0, 'whereDate'))->toHaveCount(1);
+});

package/server/tests/Unit/Support/PetroAppFuelProviderTest.php

@@ -0,0 +1,165 @@
+<?php
+
+use Fleetbase\FleetOps\Models\FuelProviderConnection;
+use Fleetbase\FleetOps\Support\FuelProviders\Providers\PetroAppFuelProvider;
+use Illuminate\Support\Carbon;
+use Illuminate\Support\Facades\Http;
+
+/**
+ * Covers the PetroApp fuel provider against faked HTTP responses: connection
+ * testing across success/failure/exception branches, paginated retrieval with
+ * multi-page traversal and failure propagation, and transaction listing with
+ * bill normalization.
+ */
+function fleetopsPetroAppFreshHttp(): void
+{
+    // Http::fake stubs accumulate on the cached facade instance; a fresh
+    // factory per scenario keeps each fake isolated.
+    Http::clearResolvedInstances();
+    app()->forgetInstance(Illuminate\Http\Client\Factory::class);
+}
+
+function fleetopsPetroAppConnection(array $credentials = []): FuelProviderConnection
+{
+    $connection = new FuelProviderConnection();
+    $connection->setRawAttributes([
+        'uuid'         => 'conn-1',
+        'company_uuid' => 'company-1',
+        'provider'     => 'petroapp',
+        'credentials'  => json_encode(array_merge([
+            'base_url'  => 'https://petroapp.test/webservice',
+            'api_token' => 'token-123',
+        ], $credentials)),
+    ], true);
+
+    return $connection;
+}
+
+test('test connection reports success failure and exceptions', function () {
+    fleetopsPetroAppFreshHttp();
+    Http::fake([
+        'https://petroapp.test/webservice/vehicles*' => Http::response(['data' => ['total' => 12]], 200),
+    ]);
+
+    $provider = new PetroAppFuelProvider();
+    $success  = $provider->testConnection(fleetopsPetroAppConnection());
+
+    expect($success['success'])->toBeTrue()
+        ->and($success['metadata']['total_vehicles'])->toBe(12);
+
+    fleetopsPetroAppFreshHttp();
+    Http::fake([
+        'https://petroapp.test/webservice/vehicles*' => Http::response(['message' => 'Unauthorized'], 401),
+    ]);
+    $failure = $provider->testConnection(fleetopsPetroAppConnection());
+    expect($failure['success'])->toBeFalse()
+        ->and($failure['message'])->toBe('Unauthorized')
+        ->and($failure['metadata']['status'])->toBe(401);
+
+    fleetopsPetroAppFreshHttp();
+    Http::fake(function () {
+        throw new Exception('network unreachable');
+    });
+    $exception = $provider->testConnection(fleetopsPetroAppConnection());
+    expect($exception['success'])->toBeFalse()
+        ->and($exception['message'])->toBe('network unreachable');
+});
+
+test('paginated get traverses pages and lists vehicles and stations', function () {
+    fleetopsPetroAppFreshHttp();
+    Http::fake([
+        'https://petroapp.test/webservice/vehicles*' => Http::sequence()
+            ->push(['data' => ['data' => [['id' => 1]], 'last_page' => 2, 'next_page_url' => 'x']], 200)
+            ->push(['data' => ['data' => [['id' => 2]], 'last_page' => 2, 'next_page_url' => null]], 200),
+        'https://petroapp.test/webservice/petroapp_locations*' => Http::response(['locs' => [['id' => 'station-1']]], 200),
+    ]);
+
+    $provider = new PetroAppFuelProvider();
+
+    $vehicles = $provider->listVehicles(fleetopsPetroAppConnection());
+    expect($vehicles)->toHaveCount(2);
+
+    $stations = $provider->listStations(fleetopsPetroAppConnection());
+    expect($stations)->toHaveCount(1)
+        ->and($stations->first()['id'])->toBe('station-1');
+});
+
+test('paginated get raises runtime errors on failed responses', function () {
+    fleetopsPetroAppFreshHttp();
+    Http::fake([
+        'https://petroapp.test/webservice/vehicles*' => Http::response(['message' => 'Server exploded'], 500),
+    ]);
+
+    $provider = new PetroAppFuelProvider();
+
+    expect(fn () => $provider->listVehicles(fleetopsPetroAppConnection()))
+        ->toThrow(RuntimeException::class, 'Server exploded');
+});
+
+test('list transactions normalizes bills with identifiers and amounts', function () {
+    fleetopsPetroAppFreshHttp();
+    Http::fake([
+        'https://petroapp.test/webservice/bills*' => Http::response([
+            'data' => [
+                'data' => [
+                    [
+                        'id'              => 991,
+                        'bill_date'       => '2026-07-01 10:00:00',
+                        'vehicle_id'      => 'VH 12',
+                        'internal_number' => 'INT-9',
+                        'plate_snum'      => 'SGX-1',
+                        'station_name'    => 'Station A',
+                        'num_of_liters'   => '35.5',
+                        'cost'            => '120.75',
+                    ],
+                    [
+                        'bill_date'    => '2026-07-02 11:00:00',
+                        'station_name' => 'Station B',
+                        'cost'         => '80.00',
+                    ],
+                ],
+                'last_page' => 1,
+            ],
+        ], 200),
+    ]);
+
+    $provider     = new PetroAppFuelProvider();
+    $transactions = $provider->listTransactions(
+        fleetopsPetroAppConnection(['auth_type' => 'ws_sk_header']),
+        Carbon::parse('2026-07-01'),
+        Carbon::parse('2026-07-31')
+    );
+
+    expect($transactions)->toHaveCount(2)
+        ->and($transactions->first()['provider'])->toBe('petroapp')
+        ->and($transactions->first()['provider_transaction_id'])->toBe('991')
+        ->and($transactions->last()['provider_transaction_id'])->not->toBeEmpty();
+});
+
+test('provider identity and header variants resolve correctly', function () {
+    $provider = new PetroAppFuelProvider();
+
+    expect($provider->key())->toBe('petroapp')
+        ->and($provider->name())->toBe('PetroApp');
+
+    $probe = new class extends PetroAppFuelProvider {
+        public function exposeHeaders(FuelProviderConnection $connection): array
+        {
+            return $this->headers($connection);
+        }
+
+        public function exposeBaseUrl(FuelProviderConnection $connection): string
+        {
+            return $this->baseUrl($connection);
+        }
+    };
+
+    $bearer = $probe->exposeHeaders(fleetopsPetroAppConnection());
+    expect($bearer['Authorization'])->toBe('Bearer token-123');
+
+    $wsSk = $probe->exposeHeaders(fleetopsPetroAppConnection(['auth_type' => 'ws_sk_header']));
+    expect($wsSk['WS-SK'])->toBe('token-123')
+        ->and($wsSk)->not->toHaveKey('Authorization');
+
+    expect($probe->exposeBaseUrl(fleetopsPetroAppConnection()))->toBe('https://petroapp.test/webservice');
+});

package/server/tests/Unit/Support/PlaceSearchRankingTest.php

@@ -0,0 +1,191 @@
+<?php
+
+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 (!function_exists('Fleetbase\FleetOps\Support\env')) {
+    eval('namespace Fleetbase\FleetOps\Support; function env($key = null, $default = null) { return $default; }');
+}
+
+use Fleetbase\FleetOps\Models\Place;
+use Fleetbase\FleetOps\Support\Geocoding;
+use Fleetbase\FleetOps\Support\PlaceSearch;
+use Geocoder\Model\AdminLevelCollection;
+use Geocoder\Provider\GoogleMaps\Model\GoogleAddress;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+/**
+ * Covers PlaceSearch saved-place searching with relevance ranking, distance
+ * and latest orderings, geocode fallbacks through the facade including
+ * failures, query ranking and strong-match helpers, and the Geocoding
+ * geocoder construction plus place mapping from google addresses.
+ */
+function fleetopsPlaceSearchBoot(): SQLiteConnection
+{
+    $pdo = new PDO('sqlite::memory:');
+    $pdo->sqliteCreateFunction('ST_PointFromText', function ($wkt, $srid = 0, $axisOrder = null) {
+        if (is_string($wkt) && sscanf($wkt, 'POINT(%f %f)', $lng, $lat) === 2) {
+            return pack('V', 0) . pack('C', 1) . pack('V', 1) . pack('d', $lng) . pack('d', $lat);
+        }
+
+        return $wkt;
+    });
+    $pdo->sqliteCreateFunction('ST_GeomFromText', fn ($wkt, $srid = 0, $axisOrder = null) => $wkt);
+    $pdo->sqliteCreateFunction('ST_X', fn ($value) => 103.8);
+    $pdo->sqliteCreateFunction('ST_Y', fn ($value) => 1.3);
+    $pdo->sqliteCreateFunction('st_distance_sphere', fn ($a, $b) => 100.0);
+    $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');
+
+    $schema = $connection->getSchemaBuilder();
+    $schema->create('places', function ($blueprint) {
+        $blueprint->increments('id');
+        foreach (['uuid', 'public_id', 'company_uuid', 'owner_uuid', 'name', 'street1', 'street2', 'city', 'province', 'postal_code', 'country', 'location', 'meta', 'type', '_key'] as $column) {
+            $blueprint->string($column)->nullable();
+        }
+        $blueprint->timestamps();
+        $blueprint->timestamp('deleted_at')->nullable();
+    });
+
+    session(['company' => 'company-1']);
+
+    return $connection;
+}
+
+function fleetopsPlaceSearchWkb(float $lat, float $lng): string
+{
+    return pack('V', 0) . pack('C', 1) . pack('V', 1) . pack('d', $lng) . pack('d', $lat);
+}
+
+function fleetopsPlaceSearchGeocoderFake(bool $throws = false): void
+{
+    app()->instance('geocoder', new class($throws) {
+        public function __construct(public bool $throws)
+        {
+        }
+
+        public function geocode($query)
+        {
+            if ($this->throws) {
+                throw new RuntimeException('geocoder down');
+            }
+
+            return $this;
+        }
+
+        public function get()
+        {
+            return collect();
+        }
+
+        public function __call($method, $arguments)
+        {
+            return $this;
+        }
+    });
+}
+
+test('saved place search ranks relevance and merges results', function () {
+    $connection = fleetopsPlaceSearchBoot();
+    fleetopsPlaceSearchGeocoderFake();
+    $connection->table('places')->insert([
+        ['uuid' => 'p-1', 'public_id' => 'place_rank1', 'company_uuid' => 'company-1', 'name' => 'Depot', 'street1' => 'Central Rd 1', 'city' => 'Singapore', 'location' => fleetopsPlaceSearchWkb(1.30, 103.80)],
+        ['uuid' => 'p-2', 'public_id' => 'place_rank2', 'company_uuid' => 'company-1', 'name' => 'Depot Two', 'street1' => 'North Ave 2', 'city' => 'Singapore', 'location' => fleetopsPlaceSearchWkb(1.35, 103.85)],
+        ['uuid' => 'p-3', 'public_id' => 'place_rank3', 'company_uuid' => 'company-1', 'name' => 'Unrelated', 'street1' => 'South St 3', 'city' => 'Jakarta', 'location' => fleetopsPlaceSearchWkb(1.40, 103.90)],
+    ]);
+
+    $results = PlaceSearch::search(Place::where('company_uuid', 'company-1'), 'depot', ['geo' => true, 'limit' => 5]);
+    expect($results->count())->toBe(2)
+        ->and($results->first()->name)->toBe('Depot');
+});
+
+test('no query searches honor latest distance and default orderings', function () {
+    $connection = fleetopsPlaceSearchBoot();
+    fleetopsPlaceSearchGeocoderFake();
+    $connection->table('places')->insert([
+        ['uuid' => 'p-1', 'public_id' => 'place_ord1', 'company_uuid' => 'company-1', 'name' => 'Alpha', 'location' => fleetopsPlaceSearchWkb(1.30, 103.80), 'created_at' => now()->subDay()],
+        ['uuid' => 'p-2', 'public_id' => 'place_ord2', 'company_uuid' => 'company-1', 'name' => 'Beta', 'location' => fleetopsPlaceSearchWkb(1.31, 103.81), 'created_at' => now()],
+    ]);
+
+    $latest = PlaceSearch::search(Place::where('company_uuid', 'company-1'), null, ['no_query_order' => 'latest']);
+    expect($latest->first()->name)->toBe('Beta');
+
+    $default = PlaceSearch::search(Place::where('company_uuid', 'company-1'), null, []);
+    expect($default->first()->name)->toBe('Beta');
+
+    $nearby = PlaceSearch::search(Place::where('company_uuid', 'company-1'), null, ['latitude' => 1.30, 'longitude' => 103.80]);
+    expect($nearby->count())->toBe(2);
+});
+
+test('geocode falls back through the facade and swallows failures', function () {
+    fleetopsPlaceSearchBoot();
+    fleetopsPlaceSearchGeocoderFake();
+
+    expect(PlaceSearch::geocode(null))->toBeEmpty()
+        ->and(PlaceSearch::geocode('somewhere'))->toBeEmpty();
+
+    fleetopsPlaceSearchGeocoderFake(true);
+    expect(PlaceSearch::geocode('somewhere'))->toBeEmpty();
+});
+
+test('query ranking and strong match helpers compare normalized values', function () {
+    fleetopsPlaceSearchBoot();
+
+    $place = new Place();
+    $place->setRawAttributes(['uuid' => 'p-1', 'name' => 'Depot', 'street1' => 'Central Rd 1'], true);
+
+    $rank = new ReflectionMethod(PlaceSearch::class, 'placeQueryRank');
+    $rank->setAccessible(true);
+    expect($rank->invoke(null, $place, 'depot'))->toBe(0)
+        ->and($rank->invoke(null, $place, 'dep'))->toBe(1)
+        ->and($rank->invoke(null, $place, 'tral rd'))->toBe(2)
+        ->and($rank->invoke(null, $place, 'zzz'))->toBe(3)
+        ->and($rank->invoke(null, $place, null))->toBe(4);
+
+    $ranked = new ReflectionMethod(PlaceSearch::class, 'rankPlacesByQuery');
+    $ranked->setAccessible(true);
+    expect($ranked->invoke(null, collect([$place]), null)->count())->toBe(1);
+
+    $strong = new ReflectionMethod(PlaceSearch::class, 'isStrongSavedMatch');
+    $strong->setAccessible(true);
+    expect($strong->invoke(null, $place, 'depot'))->toBeTrue()
+        ->and($strong->invoke(null, $place, 'other'))->toBeFalse()
+        ->and($strong->invoke(null, $place, null))->toBeFalse();
+});
+
+test('geocoding builds geocoders and maps google addresses to places', function () {
+    fleetopsPlaceSearchBoot();
+    config()->set('services.google_maps.api_key', 'test-key');
+
+    expect(Geocoding::canGoogleGeocode())->toBeTrue();
+
+    $make = new ReflectionMethod(Geocoding::class, 'makeGeocoder');
+    $make->setAccessible(true);
+    expect($make->invoke(null))->toBeObject();
+
+    $address = new GoogleAddress('google', new AdminLevelCollection());
+    $mapper  = new ReflectionMethod(Geocoding::class, 'makePlaceFromGoogleAddress');
+    $mapper->setAccessible(true);
+    expect($mapper->invoke(null, $address))->toBeInstanceOf(Place::class);
+});