@fleetbase/fleetops-engine 0.6.58 → 0.6.59

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

@@ -0,0 +1,268 @@
+<?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; }');
+}
+
+if (!function_exists('Fleetbase\\Observers\\event')) {
+    eval('namespace Fleetbase\\Observers; function event($event = null, $payload = []) { return []; }');
+}
+
+use Fleetbase\FleetOps\Models\Place;
+use Fleetbase\FleetOps\Support\Geocoding;
+use Fleetbase\FleetOps\Support\PlaceSearch;
+use Fleetbase\LaravelMysqlSpatial\Types\Point;
+use Geocoder\Model\AddressCollection;
+use Geocoder\Provider\GoogleMaps\Model\GoogleAddress;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+/**
+ * Covers the geocoding support paths through the injectable geocoder seam:
+ * forward and reverse lookups mapping google addresses onto places, the
+ * merged query flow, reverse-geocoded place creation, and the place-search
+ * google branch — all without a live HTTP client.
+ */
+function fleetopsGeocodingInjectedBoot(): SQLiteConnection
+{
+    if (!Illuminate\Support\Str::hasMacro('humanize')) {
+        Illuminate\Support\Str::macro('humanize', fn ($value, $uppercase = true) => str_replace('_', ' ', Illuminate\Support\Str::snake((string) $value)));
+    }
+
+    $pdo      = new PDO('sqlite::memory:');
+    $wkbPoint = fn (float $lng, float $lat) => pack('V', 0) . pack('C', 1) . pack('V', 1) . pack('d', $lng) . pack('d', $lat);
+    foreach (['ST_PointFromText', 'ST_GeomFromText'] as $fn) {
+        $pdo->sqliteCreateFunction($fn, function ($wkt, $srid = 0, $axisOrder = null) use ($wkbPoint) {
+            if (is_string($wkt) && sscanf($wkt, 'POINT(%f %f)', $lng, $lat) === 2) {
+                return $wkbPoint($lng, $lat);
+            }
+
+            return $wkt;
+        });
+    }
+    $connection = new SQLiteConnection($pdo);
+    $resolver   = new ConnectionResolver(['default' => $connection, 'mysql' => $connection]);
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+    if (!EloquentModel::getEventDispatcher()) {
+        EloquentModel::setEventDispatcher(new Illuminate\Events\Dispatcher());
+    }
+    app()->instance('db', new class($connection) {
+        public function __construct(public SQLiteConnection $c)
+        {
+        }
+
+        public function connection($name = null): SQLiteConnection
+        {
+            return $this->c;
+        }
+
+        public function __call($method, $arguments)
+        {
+            return $this->c->{$method}(...$arguments);
+        }
+    });
+    Illuminate\Support\Facades\DB::clearResolvedInstance('db');
+
+    $schema = $connection->getSchemaBuilder();
+    $schema->create('places', function ($blueprint) {
+        $blueprint->increments('id');
+        foreach (['uuid', 'public_id', 'company_uuid', 'owner_uuid', 'owner_type', 'name', 'street1', 'street2', 'city', 'province', 'postal_code', 'country', 'neighborhood', 'building', 'district', 'phone', 'location', 'meta', 'type', '_key', '_import_id'] as $column) {
+            $blueprint->string($column)->nullable();
+        }
+        $blueprint->timestamps();
+        $blueprint->timestamp('deleted_at')->nullable();
+    });
+
+    app()->instance('responsecache', new class {
+        public function __call($method, $arguments)
+        {
+            return null;
+        }
+    });
+    config()->set('activitylog.enabled', false);
+    config()->set('activitylog.default_auth_driver', 'web');
+    app()->bind(Illuminate\Contracts\Config\Repository::class, fn () => config());
+    session(['company' => 'company-1']);
+
+    $address = GoogleAddress::createFromArray([
+        'providedBy'   => 'google',
+        'latitude'     => 1.34,
+        'longitude'    => 103.84,
+        'streetNumber' => '88',
+        'streetName'   => 'Injected Way',
+        'locality'     => 'Singapore',
+        'postalCode'   => '049080',
+        'country'      => 'Singapore',
+    ]);
+
+    app()->instance('geocoder', new class($address) {
+        public function __construct(public GoogleAddress $address)
+        {
+        }
+
+        public function geocode($query)
+        {
+            return $this;
+        }
+
+        public function reverse($lat, $lng)
+        {
+            return $this;
+        }
+
+        public function get()
+        {
+            return collect([$this->address]);
+        }
+
+        public function __call($method, $arguments)
+        {
+            return $this;
+        }
+    });
+    Geocoder\Laravel\Facades\Geocoder::clearResolvedInstance('geocoder');
+
+    app()->instance('fleetops.geocoder', new class($address) {
+        public array $queries = [];
+
+        public function __construct(public GoogleAddress $address)
+        {
+        }
+
+        public function geocodeQuery($query)
+        {
+            $this->queries[] = ['geocode', $query];
+
+            return new AddressCollection([$this->address]);
+        }
+
+        public function reverseQuery($query)
+        {
+            $this->queries[] = ['reverse', $query];
+
+            return new AddressCollection([$this->address]);
+        }
+    });
+
+    return $connection;
+}
+
+test('injected geocoders resolve forward reverse and merged queries', function () {
+    fleetopsGeocodingInjectedBoot();
+
+    // Forward geocoding maps google addresses onto places
+    $forward = Geocoding::geocode('88 Injected Way', 1.30, 103.80);
+    expect($forward)->toHaveCount(1)
+        ->and($forward->first())->toBeInstanceOf(Place::class)
+        ->and($forward->first()->street1)->toContain('Injected Way');
+
+    // Forward geocoding without a location bias uses the plain query mode
+    expect(Geocoding::geocode('88 Injected Way'))->toHaveCount(1);
+
+    // Reverse geocoding from coordinates and query-biased reverse lookups
+    expect(Geocoding::reverseFromCoordinates(1.34, 103.84))->toHaveCount(1)
+        ->and(Geocoding::reverseFromCoordinates(1.34, 103.84, '88 Injected Way'))->toHaveCount(1)
+        ->and(Geocoding::reverseFromQuery('88 Injected Way', 1.34, 103.84))->toHaveCount(1);
+
+    // The merged query flow dedupes by street
+    expect(Geocoding::query('88 Injected Way', 1.34, 103.84))->toHaveCount(1);
+});
+
+test('reverse geocoded places and google place search use the injected client', function () {
+    $connection = fleetopsGeocodingInjectedBoot();
+
+    // Reverse-geocoded place creation persists the resolved address
+    $place = Place::createFromReverseGeocodingLookup(new Point(1.34, 103.84), true);
+    expect($place)->toBeInstanceOf(Place::class)
+        ->and($connection->table('places')->count())->toBeGreaterThanOrEqual(1);
+
+    // The google-capable place search branch ranks the injected results
+    config()->set('services.google_maps.api_key', 'injected-test-key');
+    $results = PlaceSearch::geocode('88 Injected Way', 1.34, 103.84);
+    expect($results)->toHaveCount(1);
+
+    $reverseOnly = PlaceSearch::geocode(null, 1.34, 103.84);
+    expect($reverseOnly)->toHaveCount(1);
+    config()->set('services.google_maps.api_key', null);
+});
+
+test('place creation flows consume injected geocoding results', function () {
+    $connection = fleetopsGeocodingInjectedBoot();
+
+    // Forward lookups resolve into google-address places
+    $fromLookup = Place::createFromGeocodingLookup('88 Injected Way');
+    expect($fromLookup)->toBeInstanceOf(Place::class)
+        ->and($fromLookup->street1)->toContain('Injected Way');
+
+    // Coordinate creation enriches the place from reverse results
+    $fromCoordinates = Place::createFromCoordinates([1.34, 103.84], [], true);
+    expect($fromCoordinates)->toBeInstanceOf(Place::class);
+
+    // Single-column imports adopt the first geocoding result
+    $imported = Place::createFromImport(['address' => '88 Injected Way'], true);
+    expect($imported)->toBeInstanceOf(Place::class)
+        ->and($connection->table('places')->count())->toBeGreaterThanOrEqual(1);
+});
+
+test('place search swallows geocoder failures and returns empty defaults', function () {
+    fleetopsGeocodingInjectedBoot();
+
+    // Failing injected geocoders are swallowed inside the google branch
+    config()->set('services.google_maps.api_key', 'injected-test-key');
+    app()->instance('fleetops.geocoder', new class {
+        public function geocodeQuery($query)
+        {
+            throw new RuntimeException('geocode backend down');
+        }
+
+        public function reverseQuery($query)
+        {
+            throw new RuntimeException('reverse backend down');
+        }
+    });
+    expect(PlaceSearch::geocode('88 Injected Way', 1.34, 103.84))->toHaveCount(0);
+
+    // Without a google key and no query the search returns empty
+    config()->set('services.google_maps.api_key', null);
+    expect(PlaceSearch::geocode(null))->toHaveCount(0);
+
+    // Failures in the fallback geocoder facade collapse to empty results
+    app()->instance('geocoder', new class {
+        public function geocode($query)
+        {
+            throw new RuntimeException('facade geocoder down');
+        }
+
+        public function __call($method, $arguments)
+        {
+            return $this;
+        }
+    });
+    Geocoder\Laravel\Facades\Geocoder::clearResolvedInstance('geocoder');
+    expect(PlaceSearch::geocode('anywhere'))->toHaveCount(0);
+});
+
+test('locale and region resolve independently from configuration', function () {
+    // Google treats these as two different parameters: `language` decides what
+    // language results come back in, `region` (a ccTLD) only biases ranking.
+    // They are read from separate config keys so setting one cannot silently
+    // change the other.
+    config()->set('services.google_maps.locale', 'ru');
+    config()->set('services.google_maps.region', 'sg');
+
+    expect(Geocoding::getLocale())->toBe('ru')
+        ->and(Geocoding::getRegion())->toBe('sg');
+
+    // Unset, each falls back to its own documented default
+    config()->set('services.google_maps.locale', null);
+    config()->set('services.google_maps.region', null);
+
+    expect(Geocoding::getLocale())->toBe('en')
+        ->and(Geocoding::getRegion())->toBe('us');
+});

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

@@ -0,0 +1,32 @@
+<?php
+
+use Fleetbase\FleetOps\Support\Geocoding;
+
+/**
+ * Covers Geocoding::locate(): provider failures are re-thrown to the caller
+ * rather than swallowed, so a broken geocoder surfaces instead of silently
+ * returning an empty result set.
+ */
+test('locate rethrows geocoder provider failures', function () {
+    app()->instance('fleetops.geocoder', new class {
+        public function geocodeQuery($query)
+        {
+            throw new RuntimeException('geocoder provider unavailable');
+        }
+
+        public function reverseQuery($query)
+        {
+            throw new RuntimeException('geocoder provider unavailable');
+        }
+
+        public function __call($method, $arguments)
+        {
+            throw new RuntimeException('geocoder provider unavailable');
+        }
+    });
+
+    expect(fn () => Geocoding::locate('1 Marina Bay', 1.30, 103.80))
+        ->toThrow(RuntimeException::class, 'geocoder provider unavailable');
+
+    app()->forgetInstance('fleetops.geocoder');
+});

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

@@ -0,0 +1,188 @@
+<?php
+
+use Fleetbase\FleetOps\Models\ServiceArea;
+use Fleetbase\FleetOps\Models\Zone;
+use Fleetbase\FleetOps\Support\GeofenceIntersectionService;
+use Fleetbase\LaravelMysqlSpatial\Types\Point;
+
+class FleetOpsUnitGeofenceIntersectionAlgorithmProbe extends GeofenceIntersectionService
+{
+    public array $zoneQueries        = [];
+    public array $serviceAreaQueries = [];
+    public array $stateQueries       = [];
+    public array $geofenceLookups    = [];
+    public $zones;
+    public $serviceAreas;
+    public $states;
+    public array $geofences = [];
+
+    public function detectForTest(Point $point): array
+    {
+        return $this->detectSubjectCrossings('company-uuid', $point, 'subject_states', 'subject_uuid', 'subject-uuid');
+    }
+
+    protected function insideZones(string $companyUuid, string $wkt)
+    {
+        $this->zoneQueries[] = [$companyUuid, $wkt];
+
+        return collect($this->zones);
+    }
+
+    protected function insideServiceAreas(string $companyUuid, string $wkt)
+    {
+        $this->serviceAreaQueries[] = [$companyUuid, $wkt];
+
+        return collect($this->serviceAreas);
+    }
+
+    protected function currentSubjectStates(string $stateTable, string $subjectColumn, string $subjectUuid)
+    {
+        $this->stateQueries[] = [$stateTable, $subjectColumn, $subjectUuid];
+
+        return collect($this->states)->keyBy('geofence_uuid');
+    }
+
+    protected function findGeofence(string $geofenceType, string $geofenceUuid)
+    {
+        $this->geofenceLookups[] = [$geofenceType, $geofenceUuid];
+
+        return $this->geofences[$geofenceType . ':' . $geofenceUuid] ?? null;
+    }
+}
+
+function fleetopsUnitGeofenceZone(string $uuid): Zone
+{
+    $zone = new Zone();
+    $zone->setRawAttributes([
+        'uuid'         => $uuid,
+        'company_uuid' => 'company-uuid',
+    ], true);
+
+    return $zone;
+}
+
+function fleetopsUnitGeofenceServiceArea(string $uuid): ServiceArea
+{
+    $serviceArea = new ServiceArea();
+    $serviceArea->setRawAttributes([
+        'uuid'         => $uuid,
+        'company_uuid' => 'company-uuid',
+    ], true);
+
+    return $serviceArea;
+}
+
+test('geofence intersection algorithm detects entries exits and ignores unchanged inside states', function () {
+    $enteredZone       = fleetopsUnitGeofenceZone('zone-entered');
+    $unchangedZone     = fleetopsUnitGeofenceZone('zone-unchanged');
+    $enteredArea       = fleetopsUnitGeofenceServiceArea('area-entered');
+    $exitedArea        = fleetopsUnitGeofenceServiceArea('area-exited');
+    $missingExitedZone = 'zone-missing';
+
+    $service               = new FleetOpsUnitGeofenceIntersectionAlgorithmProbe();
+    $service->zones        = [$enteredZone, $unchangedZone];
+    $service->serviceAreas = [$enteredArea];
+    $service->states       = [
+        (object) ['geofence_uuid' => 'zone-unchanged', 'geofence_type' => 'zone', 'is_inside' => true],
+        (object) ['geofence_uuid' => 'area-entered', 'geofence_type' => 'service_area', 'is_inside' => false],
+        (object) ['geofence_uuid' => 'area-exited', 'geofence_type' => 'service_area', 'is_inside' => true],
+        (object) ['geofence_uuid' => $missingExitedZone, 'geofence_type' => 'zone', 'is_inside' => true],
+    ];
+    $service->geofences = [
+        'service_area:area-exited' => $exitedArea,
+    ];
+
+    $crossings = $service->detectForTest(new Point(1.25, 103.85));
+
+    expect($service->zoneQueries)->toBe([['company-uuid', 'POINT(103.85 1.25)']])
+        ->and($service->serviceAreaQueries)->toBe([['company-uuid', 'POINT(103.85 1.25)']])
+        ->and($service->stateQueries)->toBe([['subject_states', 'subject_uuid', 'subject-uuid']])
+        ->and($service->geofenceLookups)->toBe([
+            ['service_area', 'area-exited'],
+            ['zone', $missingExitedZone],
+        ])
+        ->and($crossings)->toHaveCount(3)
+        ->and($crossings[0])->toMatchArray([
+            'type'          => 'entered',
+            'geofence_type' => 'zone',
+        ])
+        ->and($crossings[0]['geofence'])->toBe($enteredZone)
+        ->and($crossings[1])->toMatchArray([
+            'type'          => 'entered',
+            'geofence_type' => 'service_area',
+        ])
+        ->and($crossings[1]['geofence'])->toBe($enteredArea)
+        ->and($crossings[2])->toMatchArray([
+            'type'          => 'exited',
+            'geofence_type' => 'service_area',
+        ])
+        ->and($crossings[2]['geofence'])->toBe($exitedArea);
+});
+
+test('real geofence queries filter triggered borders and resolve records', function () {
+    $pdo = new PDO('sqlite::memory:');
+    $pdo->sqliteCreateFunction('MBRContains', fn ($border, $point) => 1);
+    $pdo->sqliteCreateFunction('ST_Contains', fn ($border, $point) => 1);
+    $pdo->sqliteCreateFunction('ST_GeomFromText', fn ($wkt, $srid = 0, $axisOrder = null) => $wkt);
+    $connection = new Illuminate\Database\SQLiteConnection($pdo);
+    $resolver   = new Illuminate\Database\ConnectionResolver(['default' => $connection, 'mysql' => $connection]);
+    $resolver->setDefaultConnection('mysql');
+    Illuminate\Database\Eloquent\Model::setConnectionResolver($resolver);
+    app()->instance('db', new class($connection) {
+        public function __construct(public Illuminate\Database\SQLiteConnection $c)
+        {
+        }
+
+        public function connection($name = null): Illuminate\Database\SQLiteConnection
+        {
+            return $this->c;
+        }
+
+        public function __call($method, $arguments)
+        {
+            return $this->c->{$method}(...$arguments);
+        }
+    });
+    Illuminate\Support\Facades\DB::clearResolvedInstance('db');
+
+    $schema = $connection->getSchemaBuilder();
+    foreach (['zones' => ['uuid', 'company_uuid', 'name', 'border', 'trigger_on_entry', 'trigger_on_exit', 'dwell_threshold_minutes', 'service_area_uuid', 'public_id'], 'service_areas' => ['uuid', 'company_uuid', 'name', 'border', 'trigger_on_entry', 'trigger_on_exit', 'dwell_threshold_minutes', 'public_id']] 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();
+        });
+    }
+    $schema->create('driver_geofence_states', function ($blueprint) {
+        $blueprint->increments('id');
+        foreach (['driver_uuid', 'geofence_uuid', 'geofence_type', 'entered_at', 'exited_at'] as $column) {
+            $blueprint->string($column)->nullable();
+        }
+        $blueprint->integer('is_inside')->nullable();
+        $blueprint->timestamps();
+    });
+
+    $connection->table('zones')->insert([
+        ['uuid' => 'zone-real-1', 'company_uuid' => 'company-1', 'name' => 'Triggered', 'border' => 'POLYGON', 'trigger_on_entry' => 1],
+        ['uuid' => 'zone-real-2', 'company_uuid' => 'company-1', 'name' => 'Untriggered', 'border' => null, 'trigger_on_entry' => null],
+    ]);
+    $connection->table('service_areas')->insert(['uuid' => 'sa-real-1', 'company_uuid' => 'company-1', 'name' => 'Area', 'border' => 'POLYGON', 'trigger_on_exit' => 1]);
+    $connection->table('driver_geofence_states')->insert(['driver_uuid' => 'driver-1', 'geofence_uuid' => 'zone-real-1', 'geofence_type' => 'zone', 'is_inside' => 1]);
+
+    $service = new GeofenceIntersectionService();
+    $invoke  = function (string $name, ...$arguments) use ($service) {
+        $reflection = new ReflectionMethod(GeofenceIntersectionService::class, $name);
+        $reflection->setAccessible(true);
+
+        return $reflection->invoke($service, ...$arguments);
+    };
+
+    expect($invoke('insideZones', 'company-1', 'POINT(103.8 1.3)'))->toHaveCount(1)
+        ->and($invoke('insideServiceAreas', 'company-1', 'POINT(103.8 1.3)'))->toHaveCount(1)
+        ->and($invoke('currentSubjectStates', 'driver_geofence_states', 'driver_uuid', 'driver-1')->has('zone-real-1'))->toBeTrue()
+        ->and($invoke('findGeofence', 'zone', 'zone-real-1')?->uuid)->toBe('zone-real-1')
+        ->and($invoke('findGeofence', 'service_area', 'sa-real-1')?->uuid)->toBe('sa-real-1');
+});

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

@@ -0,0 +1,164 @@
+<?php
+
+use Fleetbase\FleetOps\Support\GettingStarted;
+use Fleetbase\Models\Company;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+class FleetOpsGettingStartedUnitDatabaseProbe
+{
+    public function __construct(private SQLiteConnection $connection)
+    {
+    }
+
+    public function connection(): SQLiteConnection
+    {
+        return $this->connection;
+    }
+}
+
+function fleetopsGettingStartedUnitUseInMemoryConnection(): SQLiteConnection
+{
+    $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
+    $connection->statement('create table users (uuid varchar(64), deleted_at datetime null)');
+    $connection->statement('create table drivers (uuid varchar(64), company_uuid varchar(64), user_uuid varchar(64), deleted_at datetime null)');
+    $connection->statement('create table orders (uuid varchar(64), company_uuid varchar(64), driver_assigned_uuid varchar(64) null, deleted_at datetime null)');
+    $connection->statement('create table tracking_statuses (uuid varchar(64), company_uuid varchar(64), tracking_number_uuid varchar(64) null, code varchar(64) null, deleted_at datetime null)');
+
+    $resolver = new ConnectionResolver([
+        'default' => $connection,
+        'mysql'   => $connection,
+    ]);
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+    app()->instance('db', new FleetOpsGettingStartedUnitDatabaseProbe($connection));
+
+    return $connection;
+}
+
+function fleetopsGettingStartedUnitCompany(): Company
+{
+    $company = new Company();
+    $company->setRawAttributes(['uuid' => 'company-onboarding'], true);
+
+    return $company;
+}
+
+test('getting started checklist reports empty onboarding state', function () {
+    fleetopsGettingStartedUnitUseInMemoryConnection();
+
+    $status = GettingStarted::forCompany(fleetopsGettingStartedUnitCompany())->get();
+
+    expect($status)->toMatchArray([
+        'profile_source' => 'generic',
+        'profile'        => null,
+        'is_completed'   => false,
+        'progress'       => [
+            'completed' => 0,
+            'total'     => 4,
+            'percent'   => 0,
+        ],
+        'next_step' => 'add_driver',
+    ])
+        ->and(array_column($status['steps'], 'key'))->toBe([
+            'add_driver',
+            'create_order',
+            'assign_driver',
+            'update_activity',
+        ])
+        ->and(array_column($status['steps'], 'completed'))->toBe([false, false, false, false])
+        ->and($status['steps'][0])->toMatchArray([
+            'title'    => 'Add a driver',
+            'estimate' => '2 min',
+            'icon'     => 'id-card',
+            'route'    => 'console.fleet-ops.management.drivers.index.new',
+        ])
+        ->and(array_column($status['recommendations'], 'key'))->toBe([
+            'route_optimization',
+            'live_fleet',
+            'service_rates',
+            'customer_portal',
+        ]);
+});
+
+test('getting started checklist tracks partial fleet setup', function () {
+    $connection = fleetopsGettingStartedUnitUseInMemoryConnection();
+    $connection->table('users')->insert([
+        'uuid'       => 'user-uuid',
+        'deleted_at' => null,
+    ]);
+    $connection->table('drivers')->insert([
+        'uuid'         => 'driver-uuid',
+        'company_uuid' => 'company-onboarding',
+        'user_uuid'    => 'user-uuid',
+        'deleted_at'   => null,
+    ]);
+    $connection->table('orders')->insert([
+        'uuid'                 => 'order-uuid',
+        'company_uuid'         => 'company-onboarding',
+        'driver_assigned_uuid' => null,
+        'deleted_at'           => null,
+    ]);
+    $connection->table('tracking_statuses')->insert([
+        'uuid'                 => 'tracking-created',
+        'company_uuid'         => 'company-onboarding',
+        'tracking_number_uuid' => 'tracking-number',
+        'code'                 => 'ORDER_CREATED',
+        'deleted_at'           => null,
+    ]);
+
+    $status = GettingStarted::forCompany(fleetopsGettingStartedUnitCompany())->get();
+
+    expect($status['progress'])->toBe([
+        'completed' => 2,
+        'total'     => 4,
+        'percent'   => 50,
+    ])
+        ->and($status['next_step'])->toBe('assign_driver')
+        ->and(array_column($status['steps'], 'completed'))->toBe([true, true, false, false]);
+});
+
+test('getting started checklist reports completion after assignment and activity', function () {
+    $connection = fleetopsGettingStartedUnitUseInMemoryConnection();
+    $connection->table('users')->insert([
+        'uuid'       => 'user-uuid',
+        'deleted_at' => null,
+    ]);
+    $connection->table('drivers')->insert([
+        'uuid'         => 'driver-uuid',
+        'company_uuid' => 'company-onboarding',
+        'user_uuid'    => 'user-uuid',
+        'deleted_at'   => null,
+    ]);
+    $connection->table('orders')->insert([
+        'uuid'                 => 'order-uuid',
+        'company_uuid'         => 'company-onboarding',
+        'driver_assigned_uuid' => 'driver-uuid',
+        'deleted_at'           => null,
+    ]);
+    $connection->table('tracking_statuses')->insert([
+        'uuid'                 => 'tracking-in-transit',
+        'company_uuid'         => 'company-onboarding',
+        'tracking_number_uuid' => 'tracking-number',
+        'code'                 => 'IN_TRANSIT',
+        'deleted_at'           => null,
+    ]);
+
+    $status = GettingStarted::forCompany(fleetopsGettingStartedUnitCompany())->get();
+
+    expect($status)->toMatchArray([
+        'is_completed' => true,
+        'progress'     => [
+            'completed' => 4,
+            'total'     => 4,
+            'percent'   => 100,
+        ],
+        'next_step' => null,
+    ])
+        ->and(array_column($status['steps'], 'completed'))->toBe([true, true, true, true])
+        ->and($status['recommendations'][1])->toMatchArray([
+            'title'  => 'Live Fleet Map',
+            'accent' => 'green',
+        ]);
+});