@fleetbase/fleetops-engine 0.6.50 → 0.6.52

package/server/tests/DriverVehicleStatusDefaultTest.php

@@ -11,14 +11,14 @@ test('driver and vehicle statuses default to available', function () {
 });
 
 test('legacy active and null driver and vehicle statuses normalize to available', function () {
-    $driver = new Driver();
+    $driver         = new Driver();
     $driver->status = 'active';
     expect($driver->status)->toBe('available');
 
     $driver->status = null;
     expect($driver->status)->toBe('available');
 
-    $vehicle = new Vehicle();
+    $vehicle         = new Vehicle();
     $vehicle->status = 'active';
     expect($vehicle->status)->toBe('available');
 

package/server/tests/FuelProviderRegistryTest.php

@@ -0,0 +1,416 @@
+<?php
+
+use Fleetbase\FleetOps\Contracts\FuelProvider;
+use Fleetbase\FleetOps\Models\FuelProviderConnection;
+use Fleetbase\FleetOps\Models\FuelProviderTransaction;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Support\FuelProviders\FuelProviderDescriptor;
+use Fleetbase\FleetOps\Support\FuelProviders\FuelProviderRegistry;
+use Fleetbase\FleetOps\Support\FuelProviders\FuelProviderService;
+use Illuminate\Support\Carbon;
+use Illuminate\Support\Collection;
+
+test('native and extension fuel providers are exposed through the shared registry', function () {
+    $registry = new FuelProviderRegistry();
+
+    expect($registry->has('petroapp'))->toBeTrue();
+
+    if (!$registry->has('test_fuel_provider')) {
+        $registry->register(new FuelProviderDescriptor([
+            'key'             => 'test_fuel_provider',
+            'label'           => 'Test Fuel Provider',
+            'type'            => 'extension',
+            'driver_class'    => TestFuelProvider::class,
+            'description'     => 'Test extension fuel provider.',
+            'category'        => 'Fuel card integration',
+            'icon'            => 'gas-pump',
+            'required_fields' => [
+                [
+                    'name'     => 'api_key',
+                    'label'    => 'API Key',
+                    'type'     => 'password',
+                    'required' => true,
+                ],
+            ],
+            'capabilities'  => ['vehicles', 'transactions', 'stations'],
+            'sync_defaults' => [
+                'window_days'              => 7,
+                'matching_order'           => ['plate_number', 'internal_id', 'vin', 'serial_number', 'call_sign', 'fuel_card_number', 'trip_number'],
+                'auto_create_fuel_reports' => true,
+            ],
+        ]));
+    }
+
+    $providers = (new FuelProviderService($registry))->providers();
+
+    expect($registry->has('test_fuel_provider'))->toBeTrue()
+        ->and($registry->resolve('test_fuel_provider'))->toBeInstanceOf(TestFuelProvider::class)
+        ->and($providers->pluck('key')->all())->toContain('petroapp', 'test_fuel_provider')
+        ->and($providers->firstWhere('key', 'test_fuel_provider')['type'])->toBe('extension')
+        ->and($providers->firstWhere('key', 'test_fuel_provider')['capabilities'])->toBe(['vehicles', 'transactions', 'stations'])
+        ->and($providers->firstWhere('key', 'test_fuel_provider')['category'])->toBe('Fuel card integration')
+        ->and($providers->firstWhere('key', 'test_fuel_provider')['sync_defaults']['window_days'])->toBe(7);
+});
+
+test('fuel provider service records sync runs and review states', function () {
+    session(['company' => '00000000-0000-0000-0000-000000000001']);
+
+    $registry = new FuelProviderRegistry();
+    if (!$registry->has('test_fuel_provider')) {
+        $registry->register(new FuelProviderDescriptor([
+            'key'          => 'test_fuel_provider',
+            'label'        => 'Test Fuel Provider',
+            'type'         => 'extension',
+            'driver_class' => TestFuelProvider::class,
+        ]));
+    }
+
+    $service    = new FuelProviderService($registry);
+    $connection = FuelProviderConnection::create([
+        'company_uuid' => session('company'),
+        'provider'     => 'test_fuel_provider',
+        'name'         => 'Test Fuel',
+        'environment'  => 'production',
+        'status'       => 'configured',
+    ]);
+
+    $syncRun = $service->createSyncRun($connection, Carbon::parse('2026-06-01'), Carbon::parse('2026-06-02'));
+
+    expect($syncRun->provider)->toBe('test_fuel_provider')
+        ->and($syncRun->status)->toBe('queued');
+
+    $transaction = FuelProviderTransaction::create([
+        'company_uuid'                  => session('company'),
+        'fuel_provider_connection_uuid' => $connection->uuid,
+        'provider'                      => 'test_fuel_provider',
+        'provider_transaction_id'       => 'txn-1',
+        'sync_status'                   => 'unmatched',
+    ]);
+
+    $reviewed = $service->reviewTransaction($transaction, 'reviewed');
+
+    expect($reviewed->sync_status)->toBe('reviewed')
+        ->and($reviewed->meta['review_status'])->toBe('reviewed');
+});
+
+test('fuel provider matching defaults to plate before provider or internal identifiers', function () {
+    session(['company' => '00000000-0000-0000-0000-000000000001']);
+
+    $registry = new FuelProviderRegistry();
+    if (!$registry->has('test_fuel_provider')) {
+        $registry->register(new FuelProviderDescriptor([
+            'key'          => 'test_fuel_provider',
+            'label'        => 'Test Fuel Provider',
+            'type'         => 'extension',
+            'driver_class' => TestFuelProvider::class,
+        ]));
+    }
+
+    $service       = new FuelProviderService($registry);
+    $internalMatch = Vehicle::create([
+        'company_uuid'  => session('company'),
+        'public_id'     => 'vehicle_internal_default_priority',
+        'internal_id'   => 'MATCH-001',
+        'plate_number'  => 'INTERNAL-ONLY',
+    ]);
+    $plateMatch = Vehicle::create([
+        'company_uuid'  => session('company'),
+        'public_id'     => 'vehicle_plate_default_priority',
+        'internal_id'   => 'PLATE-ONLY',
+        'plate_number'  => 'MATCH-001',
+    ]);
+    $connection = FuelProviderConnection::create([
+        'company_uuid'  => session('company'),
+        'provider'      => 'test_fuel_provider',
+        'name'          => 'Test Fuel',
+        'environment'   => 'production',
+        'status'        => 'configured',
+        'sync_settings' => [
+            'auto_create_fuel_reports' => false,
+        ],
+    ]);
+
+    $transaction = $service->ingestTransaction($connection, [
+        'provider'                => 'test_fuel_provider',
+        'provider_transaction_id' => 'txn-default-plate-first',
+        'provider_vehicle_id'     => $internalMatch->public_id,
+        'internal_number'         => 'MATCH-001',
+        'plate_number'            => 'MATCH-001',
+    ]);
+
+    expect($transaction->vehicle_uuid)->toBe($plateMatch->uuid);
+});
+
+test('fuel provider matching upgrades old provider-first defaults to production defaults', function () {
+    session(['company' => '00000000-0000-0000-0000-000000000001']);
+
+    $registry = new FuelProviderRegistry();
+    if (!$registry->has('test_fuel_provider')) {
+        $registry->register(new FuelProviderDescriptor([
+            'key'          => 'test_fuel_provider',
+            'label'        => 'Test Fuel Provider',
+            'type'         => 'extension',
+            'driver_class' => TestFuelProvider::class,
+        ]));
+    }
+
+    $service       = new FuelProviderService($registry);
+    $internalMatch = Vehicle::create([
+        'company_uuid'  => session('company'),
+        'public_id'     => 'vehicle_internal_legacy_priority',
+        'internal_id'   => 'MATCH-LEGACY',
+        'plate_number'  => 'INTERNAL-LEGACY',
+    ]);
+    $plateMatch = Vehicle::create([
+        'company_uuid'  => session('company'),
+        'public_id'     => 'vehicle_plate_legacy_priority',
+        'internal_id'   => 'PLATE-LEGACY',
+        'plate_number'  => 'MATCH-LEGACY',
+    ]);
+    $connection = FuelProviderConnection::create([
+        'company_uuid'  => session('company'),
+        'provider'      => 'test_fuel_provider',
+        'name'          => 'Test Fuel',
+        'environment'   => 'production',
+        'status'        => 'configured',
+        'sync_settings' => [
+            'matching_order'           => ['provider_vehicle_id', 'internal_number', 'structure_number', 'plate_number', 'vehicle_card_id', 'trip_number'],
+            'auto_create_fuel_reports' => false,
+        ],
+    ]);
+
+    $transaction = $service->ingestTransaction($connection, [
+        'provider'                => 'test_fuel_provider',
+        'provider_transaction_id' => 'txn-legacy-default-upgrade',
+        'provider_vehicle_id'     => $internalMatch->public_id,
+        'internal_number'         => 'MATCH-LEGACY',
+        'plate_number'            => 'MATCH-LEGACY',
+    ]);
+
+    expect($transaction->vehicle_uuid)->toBe($plateMatch->uuid);
+});
+
+test('fuel provider matching honors configured identifier priority', function () {
+    session(['company' => '00000000-0000-0000-0000-000000000001']);
+
+    $registry = new FuelProviderRegistry();
+    if (!$registry->has('test_fuel_provider')) {
+        $registry->register(new FuelProviderDescriptor([
+            'key'          => 'test_fuel_provider',
+            'label'        => 'Test Fuel Provider',
+            'type'         => 'extension',
+            'driver_class' => TestFuelProvider::class,
+        ]));
+    }
+
+    $service       = new FuelProviderService($registry);
+    $internalMatch = Vehicle::create([
+        'company_uuid'  => session('company'),
+        'public_id'     => 'vehicle_internal_configured_priority',
+        'internal_id'   => 'MATCH-002',
+        'plate_number'  => 'INTERNAL-ONLY-2',
+    ]);
+    $plateMatch = Vehicle::create([
+        'company_uuid'  => session('company'),
+        'public_id'     => 'vehicle_plate_configured_priority',
+        'internal_id'   => 'PLATE-ONLY-2',
+        'plate_number'  => 'MATCH-002',
+    ]);
+    $connection = FuelProviderConnection::create([
+        'company_uuid'  => session('company'),
+        'provider'      => 'test_fuel_provider',
+        'name'          => 'Test Fuel',
+        'environment'   => 'production',
+        'status'        => 'configured',
+        'sync_settings' => [
+            'matching_order'           => ['internal_id', 'plate_number'],
+            'auto_create_fuel_reports' => false,
+        ],
+    ]);
+
+    $internalFirst = $service->ingestTransaction($connection, [
+        'provider'                => 'test_fuel_provider',
+        'provider_transaction_id' => 'txn-internal-first',
+        'internal_number'         => 'MATCH-002',
+        'plate_number'            => 'MATCH-002',
+    ]);
+
+    $connection->sync_settings = [
+        'matching_order'           => ['plate_number', 'internal_id'],
+        'auto_create_fuel_reports' => false,
+    ];
+    $connection->save();
+
+    $plateFirst = $service->ingestTransaction($connection->fresh(), [
+        'provider'                => 'test_fuel_provider',
+        'provider_transaction_id' => 'txn-plate-first',
+        'internal_number'         => 'MATCH-002',
+        'plate_number'            => 'MATCH-002',
+    ]);
+
+    expect($internalFirst->vehicle_uuid)->toBe($internalMatch->uuid)
+        ->and($plateFirst->vehicle_uuid)->toBe($plateMatch->uuid);
+});
+
+test('fuel provider matching resolves production vehicle identity fields', function () {
+    session(['company' => '00000000-0000-0000-0000-000000000001']);
+
+    $registry = new FuelProviderRegistry();
+    if (!$registry->has('test_fuel_provider')) {
+        $registry->register(new FuelProviderDescriptor([
+            'key'          => 'test_fuel_provider',
+            'label'        => 'Test Fuel Provider',
+            'type'         => 'extension',
+            'driver_class' => TestFuelProvider::class,
+        ]));
+    }
+
+    $service  = new FuelProviderService($registry);
+    $vinMatch = Vehicle::create([
+        'company_uuid' => session('company'),
+        'public_id'    => 'vehicle_vin_priority',
+        'vin'          => 'VIN-001',
+    ]);
+    $serialMatch = Vehicle::create([
+        'company_uuid'  => session('company'),
+        'public_id'     => 'vehicle_serial_priority',
+        'serial_number' => 'SERIAL-001',
+    ]);
+    $callSignMatch = Vehicle::create([
+        'company_uuid' => session('company'),
+        'public_id'    => 'vehicle_call_sign_priority',
+        'call_sign'    => 'CALL-001',
+    ]);
+    $fuelCardMatch = Vehicle::create([
+        'company_uuid'     => session('company'),
+        'public_id'        => 'vehicle_fuel_card_priority',
+        'fuel_card_number' => 'CARD-001',
+    ]);
+    $connection = FuelProviderConnection::create([
+        'company_uuid'  => session('company'),
+        'provider'      => 'test_fuel_provider',
+        'name'          => 'Test Fuel',
+        'environment'   => 'production',
+        'status'        => 'configured',
+        'sync_settings' => [
+            'matching_order'           => ['vin', 'serial_number', 'call_sign', 'fuel_card_number'],
+            'auto_create_fuel_reports' => false,
+        ],
+    ]);
+
+    $vinTransaction = $service->ingestTransaction($connection, [
+        'provider'                => 'test_fuel_provider',
+        'provider_transaction_id' => 'txn-vin',
+        'vin'                     => 'VIN 001',
+    ]);
+    $serialTransaction = $service->ingestTransaction($connection, [
+        'provider'                => 'test_fuel_provider',
+        'provider_transaction_id' => 'txn-serial',
+        'serial_number'           => 'SERIAL 001',
+    ]);
+    $callSignTransaction = $service->ingestTransaction($connection, [
+        'provider'                => 'test_fuel_provider',
+        'provider_transaction_id' => 'txn-call-sign',
+        'call_sign'               => 'CALL 001',
+    ]);
+    $fuelCardTransaction = $service->ingestTransaction($connection, [
+        'provider'                => 'test_fuel_provider',
+        'provider_transaction_id' => 'txn-fuel-card',
+        'vehicle_card_id'         => 'CARD 001',
+    ]);
+
+    expect($vinTransaction->vehicle_uuid)->toBe($vinMatch->uuid)
+        ->and($serialTransaction->vehicle_uuid)->toBe($serialMatch->uuid)
+        ->and($callSignTransaction->vehicle_uuid)->toBe($callSignMatch->uuid)
+        ->and($fuelCardTransaction->vehicle_uuid)->toBe($fuelCardMatch->uuid);
+});
+
+test('fuel provider matching leaves transactions unmatched when no selected identifier resolves', function () {
+    session(['company' => '00000000-0000-0000-0000-000000000001']);
+
+    $registry = new FuelProviderRegistry();
+    if (!$registry->has('test_fuel_provider')) {
+        $registry->register(new FuelProviderDescriptor([
+            'key'          => 'test_fuel_provider',
+            'label'        => 'Test Fuel Provider',
+            'type'         => 'extension',
+            'driver_class' => TestFuelProvider::class,
+        ]));
+    }
+
+    $service    = new FuelProviderService($registry);
+    $connection = FuelProviderConnection::create([
+        'company_uuid'  => session('company'),
+        'provider'      => 'test_fuel_provider',
+        'name'          => 'Test Fuel',
+        'environment'   => 'production',
+        'status'        => 'configured',
+        'sync_settings' => [
+            'matching_order'           => ['plate_number', 'internal_id'],
+            'auto_create_fuel_reports' => false,
+        ],
+    ]);
+
+    $transaction = $service->ingestTransaction($connection, [
+        'provider'                => 'test_fuel_provider',
+        'provider_transaction_id' => 'txn-unmatched',
+        'plate_number'            => 'NO-MATCH',
+        'internal_number'         => 'NO-MATCH',
+    ]);
+
+    expect($transaction->vehicle_uuid)->toBeNull()
+        ->and($transaction->sync_status)->toBe('unmatched');
+});
+
+class TestFuelProvider implements FuelProvider
+{
+    public function key(): string
+    {
+        return 'test_fuel_provider';
+    }
+
+    public function name(): string
+    {
+        return 'Test Fuel Provider';
+    }
+
+    public function authenticate(FuelProviderConnection $connection): array
+    {
+        return ['success' => true];
+    }
+
+    public function testConnection(FuelProviderConnection $connection): array
+    {
+        return ['success' => true, 'message' => 'Connected.', 'metadata' => []];
+    }
+
+    public function listVehicles(FuelProviderConnection $connection, array $options = []): Collection
+    {
+        return collect();
+    }
+
+    public function listTransactions(FuelProviderConnection $connection, Carbon $from, Carbon $to, array $options = []): Collection
+    {
+        return collect();
+    }
+
+    public function listStations(FuelProviderConnection $connection, array $options = []): Collection
+    {
+        return collect();
+    }
+
+    public function pushTrip(FuelProviderConnection $connection, array $trip): array
+    {
+        return [];
+    }
+
+    public function syncVehicle(FuelProviderConnection $connection, array $vehicle): array
+    {
+        return [];
+    }
+
+    public function webhookPayloadToTransaction(FuelProviderConnection $connection, array $payload): ?array
+    {
+        return null;
+    }
+}

package/server/tests/GettingStartedStatusTest.php

@@ -0,0 +1,21 @@
+<?php
+
+test('getting started status route is registered', function () {
+    $routes = file_get_contents(dirname(__DIR__) . '/src/routes.php');
+
+    expect($routes)
+        ->toContain("['prefix' => 'getting-started']")
+        ->toContain("\$router->get('status', 'GettingStartedController@status');");
+});
+
+test('getting started support exposes checklist and generic recommendations', function () {
+    $support = file_get_contents(dirname(__DIR__) . '/src/Support/GettingStarted.php');
+
+    expect($support)
+        ->toContain("'key'         => 'add_driver'")
+        ->toContain("'key'         => 'create_order'")
+        ->toContain("'key'         => 'assign_driver'")
+        ->toContain("'key'         => 'update_activity'")
+        ->toContain("'profile_source'  => 'generic'")
+        ->toContain("'recommendations' => \$this->recommendations()");
+});

package/server/tests/OrderActivityFlowRegressionTest.php

@@ -0,0 +1,116 @@
+<?php
+
+use Fleetbase\FleetOps\Models\Payload;
+use Fleetbase\FleetOps\Models\Place;
+use Fleetbase\FleetOps\Models\Waypoint;
+use Fleetbase\FleetOps\Support\ResolvesOrderServiceStops;
+
+function activity_flow_helper()
+{
+    return new class {
+        use ResolvesOrderServiceStops {
+            payloadServiceStops as public serviceStops;
+            payloadUsesServiceStopActivity as public usesServiceStopActivity;
+            resolveServiceStopFromKey as public resolveStop;
+        }
+    };
+}
+
+function activity_flow_place(string $key): Place
+{
+    $place            = new Place();
+    $place->uuid      = (string) Illuminate\Support\Str::uuid();
+    $place->public_id = "place_{$key}";
+    $place->id        = "place_{$key}";
+    $place->name      = ucfirst($key);
+
+    return $place;
+}
+
+function activity_flow_waypoint(Payload $payload, Place $place, int $order): Waypoint
+{
+    $waypoint                       = new Waypoint();
+    $waypoint->uuid                 = (string) Illuminate\Support\Str::uuid();
+    $waypoint->public_id            = "waypoint_{$order}";
+    $waypoint->payload_uuid         = $payload->uuid;
+    $waypoint->place_uuid           = $place->uuid;
+    $waypoint->order                = $order;
+    $waypoint->tracking_number_uuid = null;
+    $waypoint->setRelation('place', $place);
+    $waypoint->setRelation('trackingNumber', null);
+
+    return $waypoint;
+}
+
+function activity_flow_payload(?Place $pickup = null, ?Place $dropoff = null, array $waypointPlaces = [], ?Place $return = null): Payload
+{
+    $payload       = new Payload();
+    $payload->uuid = (string) Illuminate\Support\Str::uuid();
+    $payload->setRelation('pickup', $pickup);
+    $payload->setRelation('dropoff', $dropoff);
+    $payload->setRelation('return', $return);
+    $payload->setRelation('waypoints', collect($waypointPlaces));
+    $payload->setRelation('waypointMarkers', collect($waypointPlaces)->values()->map(fn (Place $place, int $index) => activity_flow_waypoint($payload, $place, $index)));
+
+    return $payload;
+}
+
+test('classic pickup and dropoff route stays order activity driven even with a destination param', function () {
+    $pickup  = activity_flow_place('pickup');
+    $dropoff = activity_flow_place('dropoff');
+    $payload = activity_flow_payload($pickup, $dropoff);
+    $helper  = activity_flow_helper();
+
+    expect($helper->usesServiceStopActivity($payload))->toBeFalse()
+        ->and($helper->resolveStop($payload, $pickup->public_id))->not->toBeNull();
+});
+
+test('pickup waypoint and dropoff route uses service stop activity in pickup waypoint dropoff order', function () {
+    $pickup   = activity_flow_place('pickup');
+    $waypoint = activity_flow_place('middle');
+    $dropoff  = activity_flow_place('dropoff');
+    $payload  = activity_flow_payload($pickup, $dropoff, [$waypoint]);
+    $helper   = activity_flow_helper();
+    $stops    = $helper->serviceStops($payload);
+
+    expect($helper->usesServiceStopActivity($payload))->toBeTrue()
+        ->and($stops)->toHaveCount(3)
+        ->and($stops->pluck('type')->all())->toBe(['pickup', 'waypoint', 'dropoff']);
+});
+
+test('pickup plus waypoints without dropoff and waypoint only routes use service stop activity', function () {
+    $pickup       = activity_flow_place('pickup');
+    $firstStop    = activity_flow_place('first');
+    $secondStop   = activity_flow_place('second');
+    $withPickup   = activity_flow_payload($pickup, null, [$firstStop, $secondStop]);
+    $waypointOnly = activity_flow_payload(null, null, [$firstStop, $secondStop]);
+    $helper       = activity_flow_helper();
+
+    expect($helper->usesServiceStopActivity($withPickup))->toBeTrue()
+        ->and($helper->serviceStops($withPickup)->pluck('type')->all())->toBe(['pickup', 'waypoint', 'waypoint'])
+        ->and($helper->usesServiceStopActivity($waypointOnly))->toBeTrue()
+        ->and($helper->serviceStops($waypointOnly)->pluck('type')->all())->toBe(['waypoint', 'waypoint']);
+});
+
+test('return address is excluded from normal service stop activity sequence', function () {
+    $pickup  = activity_flow_place('pickup');
+    $dropoff = activity_flow_place('dropoff');
+    $return  = activity_flow_place('return');
+    $payload = activity_flow_payload($pickup, $dropoff, [], $return);
+    $helper  = activity_flow_helper();
+
+    expect($helper->serviceStops($payload)->pluck('type')->all())->toBe(['pickup', 'dropoff']);
+});
+
+test('pod bypass is internal console only', function () {
+    $internalController = file_get_contents(dirname(__DIR__) . '/src/Http/Controllers/Internal/v1/OrderController.php');
+    $publicController   = file_get_contents(dirname(__DIR__) . '/src/Http/Controllers/Api/v1/OrderController.php');
+    $consoleModal       = file_get_contents(dirname(__DIR__, 2) . '/addon/components/modals/update-order-activity.hbs');
+
+    expect($internalController)
+        ->toContain("boolean('bypass_proof')")
+        ->and($publicController)
+        ->not->toContain('bypass_proof')
+        ->and($consoleModal)
+        ->toContain('Bypass proof of delivery');
+});

package/server/tests/ServiceAreaZoneApiShapeTest.php

@@ -1,5 +1,8 @@
 <?php
 
+use Fleetbase\FleetOps\Models\ServiceArea;
+use Fleetbase\FleetOps\Models\Zone;
+
 test('service area create and update accept persisted map geometry and style fields', function () {
     $controller = file_get_contents(__DIR__ . '/../src/Http/Controllers/Api/v1/ServiceAreaController.php');
 
@@ -32,3 +35,44 @@ test('zone create accepts only service area public ids on the consumable api', f
         ->toContain("'public_id'    => \$request->input('service_area')")
         ->not->toContain("->orWhere('uuid'");
 });
+
+test('service area zones relationship uses the stored service area uuid foreign key', function () {
+    $relation = (new ServiceArea())->zones();
+
+    expect($relation->getForeignKeyName())->toBe('service_area_uuid')
+        ->and($relation->getLocalKeyName())->toBe('uuid');
+});
+
+test('zone service area relationship uses the stored service area uuid foreign key', function () {
+    $relation = (new Zone())->serviceArea();
+
+    expect($relation->getForeignKeyName())->toBe('service_area_uuid')
+        ->and($relation->getOwnerKeyName())->toBe('uuid');
+});
+
+test('zone observer is registered to invalidate service area cache when zones change', function () {
+    $provider = file_get_contents(__DIR__ . '/../src/Providers/FleetOpsServiceProvider.php');
+    $observer = file_get_contents(__DIR__ . '/../src/Observers/ZoneObserver.php');
+
+    expect($provider)
+        ->toContain('\Fleetbase\FleetOps\Models\Zone::class')
+        ->toContain('\Fleetbase\FleetOps\Observers\ZoneObserver::class');
+
+    expect($observer)
+        ->toContain('function created')
+        ->toContain('function updated')
+        ->toContain('function deleted')
+        ->toContain('function restored')
+        ->toContain("\$zone->getOriginal('service_area_uuid')")
+        ->toContain('ServiceArea::invalidateApiCacheManually($zone->company_uuid)')
+        ->toContain('ServiceArea::invalidateApiCacheManually()');
+});
+
+test('internal service area controller does not bypass api cache directly', function () {
+    $controller = file_get_contents(__DIR__ . '/../src/Http/Controllers/Internal/v1/ServiceAreaController.php');
+
+    expect($controller)
+        ->not->toContain('disableApiCache')
+        ->not->toContain('function queryRecord')
+        ->not->toContain('function findRecord');
+});

package/server/tests/ServiceRateAlgorithmWeightVariablesTest.php

@@ -0,0 +1,44 @@
+<?php
+
+use Fleetbase\FleetOps\Models\Entity;
+use Fleetbase\FleetOps\Models\ServiceRate;
+
+function fleetopsServiceRateAlgorithmQuote(string $algorithm, array $entities): int
+{
+    $serviceRate = new ServiceRate([
+        'rate_calculation_method' => 'algo',
+        'algorithm'               => $algorithm,
+        'base_fee'                => 0,
+        'currency'                => 'USD',
+    ]);
+
+    [$subTotal] = $serviceRate->quoteFromPreliminaryData($entities, ['pickup', 'dropoff']);
+
+    return $subTotal;
+}
+
+test('algorithm rate variables expose summed entity weights in converted units', function () {
+    $entities = [
+        new Entity(['type' => 'parcel', 'weight' => 2, 'weight_unit' => 'kg']),
+        new Entity(['type' => 'parcel', 'weight' => 1, 'weight_unit' => 'lb']),
+    ];
+
+    expect(fleetopsServiceRateAlgorithmQuote('{weight_kg} * 1000', $entities))->toBe(2454)
+        ->and(fleetopsServiceRateAlgorithmQuote('{weight_lb} * 1000', $entities))->toBe(5410)
+        ->and(fleetopsServiceRateAlgorithmQuote('{weight_tonne} * 1000000', $entities))->toBe(2454)
+        ->and(fleetopsServiceRateAlgorithmQuote('{weight_t} * 1000000', $entities))->toBe(2454)
+        ->and(fleetopsServiceRateAlgorithmQuote('{weight} * 1000', $entities))->toBe(2454);
+});
+
+test('algorithm rate weight variables ignore missing or blank entity weights', function () {
+    $entities = [
+        new Entity(['type' => 'parcel', 'weight' => '', 'weight_unit' => 'kg']),
+        new Entity(['type' => 'parcel', 'weight' => null, 'weight_unit' => 'lb']),
+        new Entity(['type' => 'parcel', 'weight' => 500, 'weight_unit' => 'g']),
+        new Entity(['type' => 'parcel']),
+    ];
+
+    expect(fleetopsServiceRateAlgorithmQuote('{weight_kg} * 1000', $entities))->toBe(500)
+        ->and(fleetopsServiceRateAlgorithmQuote('{weight_g}', $entities))->toBe(500)
+        ->and(fleetopsServiceRateAlgorithmQuote('{weight_oz} * 1000', $entities))->toBe(17637);
+});