@fleetbase/fleetops-engine 0.6.58 → 0.6.59

package/server/tests/FuelProviderResourceContractsTest.php

@@ -0,0 +1,171 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Resources\v1\FuelProviderConnection as FuelProviderConnectionResource;
+use Fleetbase\FleetOps\Http\Resources\v1\FuelProviderSyncRun as FuelProviderSyncRunResource;
+use Fleetbase\FleetOps\Http\Resources\v1\FuelProviderTransaction as FuelProviderTransactionResource;
+use Illuminate\Http\Request;
+
+class FleetOpsResourceRouteFixture
+{
+    public function __construct(private string $uri)
+    {
+    }
+
+    public function uri(): string
+    {
+        return $this->uri;
+    }
+}
+
+function fleetopsInternalResourceRequest(): Request
+{
+    $request = Request::create('/int/v1/fleet-ops/resource-test', 'GET');
+    $request->setRouteResolver(fn () => new FleetOpsResourceRouteFixture('api/int/v1/fleet-ops/resource-test'));
+    app()->instance('request', $request);
+
+    return $request;
+}
+
+function fuelProviderResourceFixture(array $attributes): object
+{
+    return (object) $attributes;
+}
+
+test('fuel provider connection resource exposes public identifiers and sync state', function () {
+    $connection = fuelProviderResourceFixture([
+        'id'              => 12,
+        'uuid'            => 'connection-uuid',
+        'public_id'       => 'fuel_connection_public',
+        'provider'        => 'test_provider',
+        'name'            => 'Main Fuel Account',
+        'environment'     => 'production',
+        'status'          => 'configured',
+        'sync_settings'   => ['window_days' => 7],
+        'last_sync_state' => ['cursor' => 'abc'],
+        'last_synced_at'  => '2026-07-01 10:00:00',
+        'last_tested_at'  => '2026-07-01 09:00:00',
+        'last_error'      => null,
+        'meta'            => ['team' => 'ops'],
+        'updated_at'      => '2026-07-01 11:00:00',
+        'created_at'      => '2026-07-01 08:00:00',
+    ]);
+
+    $payload = (new FuelProviderConnectionResource($connection))->toArray(fleetopsInternalResourceRequest());
+
+    expect($payload)->toMatchArray([
+        'id'              => 12,
+        'public_id'       => 'fuel_connection_public',
+        'provider'        => 'test_provider',
+        'name'            => 'Main Fuel Account',
+        'environment'     => 'production',
+        'status'          => 'configured',
+        'sync_settings'   => ['window_days' => 7],
+        'last_sync_state' => ['cursor' => 'abc'],
+        'meta'            => ['team' => 'ops'],
+    ]);
+});
+
+test('fuel provider sync run resource exposes counters windows and totals', function () {
+    $syncRun = fuelProviderResourceFixture([
+        'id'                            => 55,
+        'uuid'                          => 'sync-run-uuid',
+        'public_id'                     => 'sync_run_public',
+        'fuel_provider_connection_uuid' => 'connection-uuid',
+        'provider'                      => 'test_provider',
+        'status'                        => 'finished',
+        'from'                          => '2026-06-01',
+        'to'                            => '2026-06-30',
+        'imported'                      => 10,
+        'matched'                       => 7,
+        'unmatched'                     => 3,
+        'fuel_reports_created'          => 5,
+        'liters'                        => 432.5,
+        'amount'                        => 1200,
+        'started_at'                    => '2026-07-01 09:00:00',
+        'finished_at'                   => '2026-07-01 09:05:00',
+        'error'                         => null,
+        'summary'                       => ['warnings' => 1],
+        'meta'                          => ['source' => 'manual'],
+        'updated_at'                    => '2026-07-01 09:06:00',
+        'created_at'                    => '2026-07-01 08:55:00',
+    ]);
+
+    $payload = (new FuelProviderSyncRunResource($syncRun))->toArray(fleetopsInternalResourceRequest());
+
+    expect($payload)->toMatchArray([
+        'id'                   => 55,
+        'public_id'            => 'sync_run_public',
+        'provider'             => 'test_provider',
+        'status'               => 'finished',
+        'imported'             => 10,
+        'matched'              => 7,
+        'unmatched'            => 3,
+        'fuel_reports_created' => 5,
+        'liters'               => 432.5,
+        'amount'               => 1200,
+        'summary'              => ['warnings' => 1],
+        'meta'                 => ['source' => 'manual'],
+    ]);
+});
+
+test('fuel provider transaction resource exposes identifiers matching fields and raw payloads', function () {
+    $transaction = fuelProviderResourceFixture([
+        'id'                            => 99,
+        'uuid'                          => 'transaction-uuid',
+        'public_id'                     => 'fuel_transaction_public',
+        'fuel_provider_connection_uuid' => 'connection-uuid',
+        'fuel_report_uuid'              => 'fuel-report-uuid',
+        'fuel_report_id'                => 'fuel_report_public',
+        'vehicle_uuid'                  => 'vehicle-uuid',
+        'driver_uuid'                   => 'driver-uuid',
+        'order_uuid'                    => 'order-uuid',
+        'provider'                      => 'test_provider',
+        'provider_transaction_id'       => 'txn-123',
+        'provider_vehicle_id'           => 'provider-vehicle-1',
+        'vehicle_card_id'               => 'card-1',
+        'internal_number'               => 'internal-1',
+        'structure_number'              => 'structure-1',
+        'plate_number'                  => 'ABC-123',
+        'vin'                           => 'VIN123',
+        'serial_number'                 => 'SER123',
+        'call_sign'                     => 'CALL-1',
+        'trip_number'                   => 'TRIP-1',
+        'station_name'                  => 'Station A',
+        'station_latitude'              => 1.25,
+        'station_longitude'             => 103.75,
+        'station_location'              => ['type' => 'Point', 'coordinates' => [103.75, 1.25]],
+        'transaction_at'                => '2026-07-01 12:00:00',
+        'volume'                        => 80,
+        'metric_unit'                   => 'L',
+        'amount'                        => 240,
+        'currency'                      => 'USD',
+        'odometer'                      => 12345,
+        'sync_status'                   => 'matched',
+        'matched_at'                    => '2026-07-01 12:05:00',
+        'vehicle_name'                  => 'Truck 12',
+        'driver_name'                   => 'Jane Driver',
+        'normalized_payload'            => ['amount' => 240],
+        'raw_payload'                   => ['source' => 'provider'],
+        'meta'                          => ['review_status' => 'approved'],
+        'updated_at'                    => '2026-07-01 12:06:00',
+        'created_at'                    => '2026-07-01 12:01:00',
+    ]);
+
+    $payload = (new FuelProviderTransactionResource($transaction))->toArray(fleetopsInternalResourceRequest());
+
+    expect($payload)->toMatchArray([
+        'id'                      => 99,
+        'public_id'               => 'fuel_transaction_public',
+        'provider'                => 'test_provider',
+        'provider_transaction_id' => 'txn-123',
+        'plate_number'            => 'ABC-123',
+        'station_name'            => 'Station A',
+        'station_location'        => ['type' => 'Point', 'coordinates' => [103.75, 1.25]],
+        'volume'                  => 80,
+        'metric_unit'             => 'L',
+        'amount'                  => 240,
+        'currency'                => 'USD',
+        'odometer'                => 12345,
+        'sync_status'             => 'matched',
+    ]);
+});

package/server/tests/FuelProviderTransactionControllerContractsTest.php

@@ -0,0 +1,181 @@
+<?php
+
+if (!function_exists('Fleetbase\Traits\config')) {
+    eval('namespace Fleetbase\Traits; function config($key = null, $default = null) { return $key === "api.cache.enabled" ? false : $default; }');
+}
+
+if (!function_exists('Fleetbase\Models\config')) {
+    eval('namespace Fleetbase\Models; function config($key = null, $default = null) { return $key === "fleetbase.connection.db" ? "mysql" : $default; }');
+}
+
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\FuelProviderTransactionController;
+use Fleetbase\FleetOps\Models\FuelProviderTransaction;
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Support\FuelProviders\FuelProviderService;
+use Illuminate\Http\Request;
+
+class FleetOpsFuelProviderTransactionControllerProbe extends FuelProviderTransactionController
+{
+    public FuelProviderTransaction $transaction;
+    public array $lookups = [];
+
+    protected function findTransaction(string $id): FuelProviderTransaction
+    {
+        $this->lookups[] = $id;
+
+        return $this->transaction;
+    }
+}
+
+class FleetOpsFuelProviderTransactionServiceFake extends FuelProviderService
+{
+    public array $calls = [];
+
+    public function __construct()
+    {
+    }
+
+    public function matchVehicle(FuelProviderTransaction $transaction, Vehicle|string $vehicle): FuelProviderTransaction
+    {
+        $this->calls[] = ['matchVehicle', $transaction, $vehicle];
+        $transaction->setAttribute('matched_vehicle', $vehicle);
+
+        return $transaction;
+    }
+
+    public function matchOrder(FuelProviderTransaction $transaction, Order|string $order): FuelProviderTransaction
+    {
+        $this->calls[] = ['matchOrder', $transaction, $order];
+        $transaction->setAttribute('matched_order', $order);
+
+        return $transaction;
+    }
+
+    public function reprocessTransaction(FuelProviderTransaction $transaction): FuelProviderTransaction
+    {
+        $this->calls[] = ['reprocessTransaction', $transaction];
+        $transaction->setAttribute('reprocessed', true);
+
+        return $transaction;
+    }
+
+    public function reviewTransaction(FuelProviderTransaction $transaction, string $status): FuelProviderTransaction
+    {
+        $this->calls[] = ['reviewTransaction', $transaction, $status];
+        $transaction->setAttribute('review_status', $status);
+
+        return $transaction;
+    }
+}
+
+class FleetOpsFuelProviderTransactionFake extends FuelProviderTransaction
+{
+    public function toArray(): array
+    {
+        return $this->getAttributes();
+    }
+}
+
+class FleetOpsFuelProviderTransactionQueryFake
+{
+    public array $calls = [];
+
+    public function with(array $relations): self
+    {
+        $this->calls[] = ['with', $relations];
+
+        return $this;
+    }
+}
+
+function fleetopsFuelProviderTransactionController(FleetOpsFuelProviderTransactionServiceFake $service, FuelProviderTransaction $transaction): FleetOpsFuelProviderTransactionControllerProbe
+{
+    $controller              = new FleetOpsFuelProviderTransactionControllerProbe($service);
+    $controller->transaction = $transaction;
+
+    return $controller;
+}
+
+test('fuel provider transaction controller eager loads related records for queries', function () {
+    $query = new FleetOpsFuelProviderTransactionQueryFake();
+
+    FuelProviderTransactionController::onQueryRecord($query, new Request());
+
+    expect($query->calls)->toBe([
+        ['with', ['vehicle', 'driver', 'fuelReport']],
+    ]);
+});
+
+test('fuel provider transaction controller delegates matching and review actions to service', function () {
+    $service     = new FleetOpsFuelProviderTransactionServiceFake();
+    $transaction = new FleetOpsFuelProviderTransactionFake();
+    $transaction->setRawAttributes(['uuid' => 'transaction-uuid']);
+    $controller  = fleetopsFuelProviderTransactionController($service, $transaction);
+
+    $vehicleResponse = $controller->matchVehicle(Request::create('/transactions/tx/match-vehicle', 'POST', [
+        'vehicle' => 'vehicle_public_id',
+    ]), 'fuel_provider_transaction_123');
+
+    $orderResponse = $controller->matchOrder(Request::create('/transactions/tx/match-order', 'POST', [
+        'order' => 'order_public_id',
+    ]), 'fuel_provider_transaction_123');
+
+    $reprocessResponse = $controller->reprocess(new Request(), 'fuel_provider_transaction_123');
+
+    $reviewResponse = $controller->review(Request::create('/transactions/tx/review', 'POST', [
+        'status' => 'reviewed',
+    ]), 'fuel_provider_transaction_123');
+
+    $vehicleData   = $vehicleResponse->getData(true);
+    $orderData     = $orderResponse->getData(true);
+    $reprocessData = $reprocessResponse->getData(true);
+    $reviewData    = $reviewResponse->getData(true);
+
+    expect($vehicleData['status'])->toBe('ok')
+        ->and($vehicleData['transaction']['uuid'])->toBe('transaction-uuid')
+        ->and($vehicleData['transaction']['matched_vehicle'])->toBe('vehicle_public_id')
+        ->and($orderData['status'])->toBe('ok')
+        ->and($orderData['transaction']['matched_order'])->toBe('order_public_id')
+        ->and($reprocessData['status'])->toBe('ok')
+        ->and($reprocessData['transaction']['reprocessed'])->toBeTrue()
+        ->and($reviewData['status'])->toBe('ok')
+        ->and($reviewData['transaction']['review_status'])->toBe('reviewed')
+        ->and($controller->lookups)->toBe([
+            'fuel_provider_transaction_123',
+            'fuel_provider_transaction_123',
+            'fuel_provider_transaction_123',
+            'fuel_provider_transaction_123',
+        ])
+        ->and($service->calls)->toBe([
+            ['matchVehicle', $transaction, 'vehicle_public_id'],
+            ['matchOrder', $transaction, 'order_public_id'],
+            ['reprocessTransaction', $transaction],
+            ['reviewTransaction', $transaction, 'reviewed'],
+        ]);
+});
+
+test('fuel provider transaction real lookup scopes identifier and company', function () {
+    $connection = new Illuminate\Database\SQLiteConnection(new PDO('sqlite::memory:'));
+    $resolver   = new Illuminate\Database\ConnectionResolver(['default' => $connection, 'mysql' => $connection]);
+    $resolver->setDefaultConnection('mysql');
+    Illuminate\Database\Eloquent\Model::setConnectionResolver($resolver);
+    $schema = $connection->getSchemaBuilder();
+    $schema->create('fuel_provider_transactions', function ($blueprint) {
+        $blueprint->increments('id');
+        foreach (['uuid', 'public_id', 'company_uuid', 'connection_uuid', 'provider', 'status', 'amount', 'currency', 'meta', '_key'] as $column) {
+            $blueprint->string($column)->nullable();
+        }
+        $blueprint->timestamps();
+        $blueprint->timestamp('deleted_at')->nullable();
+    });
+    session(['company' => 'company-txn-1']);
+    $connection->table('fuel_provider_transactions')->insert(['uuid' => 'fpt-real-1', 'public_id' => 'fuel_provider_transaction_real1', 'company_uuid' => 'company-txn-1', 'provider' => 'petroapp', 'status' => 'pending']);
+
+    $controller = new FleetOpsFuelProviderTransactionControllerProbe(new FleetOpsFuelProviderTransactionServiceFake());
+    $reflection = new ReflectionMethod(FuelProviderTransactionController::class, 'findTransaction');
+    $reflection->setAccessible(true);
+
+    expect($reflection->invoke($controller, 'fpt-real-1')->public_id)->toBe('fuel_provider_transaction_real1')
+        ->and($reflection->invoke($controller, 'fuel_provider_transaction_real1')->uuid)->toBe('fpt-real-1');
+});

package/server/tests/GeofenceIntersectionServiceContractsTest.php

@@ -0,0 +1,164 @@
+<?php
+
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Support\GeofenceIntersectionService;
+use Fleetbase\LaravelMysqlSpatial\Types\Point;
+use Illuminate\Support\Carbon;
+use Illuminate\Support\Facades\DB;
+
+class FleetOpsGeofenceIntersectionProbe extends GeofenceIntersectionService
+{
+    public array $calls  = [];
+    public array $result = [];
+
+    protected function detectSubjectCrossings(string $companyUuid, Point $newLocation, string $stateTable, string $subjectColumn, string $subjectUuid): array
+    {
+        $this->calls[] = compact('companyUuid', 'newLocation', 'stateTable', 'subjectColumn', 'subjectUuid');
+
+        return $this->result;
+    }
+}
+
+class FleetOpsGeofenceDbRecorder
+{
+    public array $queries;
+    public array $tables = [];
+
+    public function __construct(FleetOpsGeofenceDbQueryRecorder ...$queries)
+    {
+        $this->queries = $queries;
+    }
+
+    public function table(string $table): FleetOpsGeofenceDbQueryRecorder
+    {
+        $this->tables[] = $table;
+
+        return array_shift($this->queries) ?? new FleetOpsGeofenceDbQueryRecorder();
+    }
+}
+
+class FleetOpsGeofenceDbQueryRecorder
+{
+    public array $wheres  = [];
+    public ?array $update = null;
+    public bool $exists   = false;
+
+    public function where(string $column, mixed $operator = null, mixed $value = null, string $boolean = 'and'): self
+    {
+        $this->wheres[] = [$column, func_num_args() === 2 ? $operator : $value, $boolean];
+
+        return $this;
+    }
+
+    public function exists(): bool
+    {
+        return $this->exists;
+    }
+
+    public function update(array $payload): int
+    {
+        $this->update = $payload;
+
+        return 1;
+    }
+}
+
+function fleetopsGeofenceRecordDb(FleetOpsGeofenceDbQueryRecorder ...$queries): FleetOpsGeofenceDbRecorder
+{
+    $db = new FleetOpsGeofenceDbRecorder(...$queries);
+    app()->instance('db', $db);
+    DB::clearResolvedInstance('db');
+
+    return $db;
+}
+
+function fleetopsGeofenceDriverModel(): Driver
+{
+    $driver = new Driver();
+    $driver->setRawAttributes([
+        'uuid'         => 'driver-uuid',
+        'company_uuid' => 'company-uuid',
+    ], true);
+
+    return $driver;
+}
+
+function fleetopsGeofenceVehicleModel(): Vehicle
+{
+    $vehicle = new Vehicle();
+    $vehicle->setRawAttributes([
+        'uuid'         => 'vehicle-uuid',
+        'company_uuid' => 'company-uuid',
+    ], true);
+
+    return $vehicle;
+}
+
+test('geofence intersection service routes driver and vehicle crossing detection', function () {
+    $service         = new FleetOpsGeofenceIntersectionProbe();
+    $point           = new Point(1.3, 103.8);
+    $service->result = [['type' => 'entered']];
+
+    expect($service->detectCrossings(fleetopsGeofenceDriverModel(), $point))->toBe([['type' => 'entered']])
+        ->and($service->calls[0])->toMatchArray([
+            'companyUuid'   => 'company-uuid',
+            'stateTable'    => 'driver_geofence_states',
+            'subjectColumn' => 'driver_uuid',
+            'subjectUuid'   => 'driver-uuid',
+        ])
+        ->and($service->detectCrossings(fleetopsGeofenceVehicleModel(), $point))->toBe([['type' => 'entered']])
+        ->and($service->calls[1])->toMatchArray([
+            'companyUuid'   => 'company-uuid',
+            'stateTable'    => 'vehicle_geofence_states',
+            'subjectColumn' => 'vehicle_uuid',
+            'subjectUuid'   => 'vehicle-uuid',
+        ]);
+});
+
+test('geofence intersection service checks recorded inside state for drivers and vehicles', function () {
+    $service             = new GeofenceIntersectionService();
+    $driverQuery         = new FleetOpsGeofenceDbQueryRecorder();
+    $vehicleQuery        = new FleetOpsGeofenceDbQueryRecorder();
+    $driverQuery->exists = true;
+    $db                  = fleetopsGeofenceRecordDb($driverQuery, $vehicleQuery);
+
+    expect($service->isDriverInsideGeofence(fleetopsGeofenceDriverModel(), (object) ['uuid' => 'geofence-uuid']))->toBeTrue()
+        ->and($service->isVehicleInsideGeofence(fleetopsGeofenceVehicleModel(), (object) ['uuid' => 'geofence-uuid']))->toBeFalse()
+        ->and($db->tables)->toBe(['driver_geofence_states', 'vehicle_geofence_states'])
+        ->and($driverQuery->wheres)->toBe([
+            ['driver_uuid', 'driver-uuid', 'and'],
+            ['geofence_uuid', 'geofence-uuid', 'and'],
+            ['is_inside', true, 'and'],
+        ])
+        ->and($vehicleQuery->wheres)->toBe([
+            ['vehicle_uuid', 'vehicle-uuid', 'and'],
+            ['geofence_uuid', 'geofence-uuid', 'and'],
+            ['is_inside', true, 'and'],
+        ]);
+});
+
+test('geofence intersection service clears driver and vehicle state records', function () {
+    Carbon::setTestNow('2026-01-01 12:00:00');
+
+    $service      = new GeofenceIntersectionService();
+    $driverQuery  = new FleetOpsGeofenceDbQueryRecorder();
+    $vehicleQuery = new FleetOpsGeofenceDbQueryRecorder();
+    $db           = fleetopsGeofenceRecordDb($driverQuery, $vehicleQuery);
+
+    $service->clearDriverState(fleetopsGeofenceDriverModel());
+    $service->clearVehicleState(fleetopsGeofenceVehicleModel());
+
+    expect($db->tables)->toBe(['driver_geofence_states', 'vehicle_geofence_states'])
+        ->and($driverQuery->wheres)->toBe([['driver_uuid', 'driver-uuid', 'and']])
+        ->and($vehicleQuery->wheres)->toBe([['vehicle_uuid', 'vehicle-uuid', 'and']])
+        ->and($driverQuery->update)->toMatchArray([
+            'is_inside'    => false,
+            'dwell_job_id' => null,
+        ])
+        ->and($driverQuery->update['exited_at']->equalTo(Carbon::now()))->toBeTrue()
+        ->and($driverQuery->update['updated_at']->equalTo(Carbon::now()))->toBeTrue()
+        ->and($vehicleQuery->update['exited_at']->equalTo(Carbon::now()))->toBeTrue();
+
+    Carbon::setTestNow();
+});

package/server/tests/HOSConstraintContractsTest.php

@@ -0,0 +1,128 @@
+<?php
+
+use Fleetbase\FleetOps\Constraints\HOSConstraint;
+use Fleetbase\Models\ScheduleItem;
+use Illuminate\Support\Carbon;
+
+class FleetOpsHosScheduleItemFake extends ScheduleItem
+{
+    public int $duration;
+    public string $start_at;
+    public ?string $end_at         = null;
+    public ?string $break_start_at = null;
+    public ?string $break_end_at   = null;
+}
+
+function invokeFleetOpsHosConstraint(HOSConstraint $constraint, string $method, array $arguments = [])
+{
+    $reflection = new ReflectionMethod($constraint, $method);
+    $reflection->setAccessible(true);
+
+    return $reflection->invokeArgs($constraint, $arguments);
+}
+
+function fleetOpsScheduleItem(array $attributes): ScheduleItem
+{
+    $item = new FleetOpsHosScheduleItemFake();
+
+    foreach ($attributes as $key => $value) {
+        $item->{$key} = $value;
+    }
+
+    return $item;
+}
+
+function fleetOpsRecentScheduleItem(array $attributes): object
+{
+    return (object) $attributes;
+}
+
+test('hos constraint calculates driving hours across current and recent schedule items', function () {
+    $constraint = new HOSConstraint();
+    $current    = fleetOpsScheduleItem([
+        'duration' => 120,
+        'start_at' => '2026-07-19 12:00:00',
+    ]);
+    $recent     = collect([
+        fleetOpsRecentScheduleItem(['duration' => 90, 'start_at' => '2026-07-19 08:00:00']),
+        fleetOpsRecentScheduleItem(['duration' => 150, 'start_at' => '2026-07-19 10:00:00']),
+    ]);
+
+    expect(invokeFleetOpsHosConstraint($constraint, 'calculateTotalDrivingHours', [$current, $recent]))
+        ->toBe(6.0)
+        ->and(invokeFleetOpsHosConstraint($constraint, 'calculateDrivingHoursSince', [
+            $current,
+            $recent,
+            Carbon::parse('2026-07-19 09:00:00'),
+        ]))->toBe(4.5);
+});
+
+test('hos constraint enforces driving and weekly hour limits', function () {
+    $constraint = new HOSConstraint();
+    $current    = fleetOpsScheduleItem([
+        'duration' => 120,
+        'start_at' => '2026-07-19 12:00:00',
+    ]);
+
+    $withinLimit = collect([
+        fleetOpsRecentScheduleItem(['duration' => 300, 'start_at' => '2026-07-18 08:00:00']),
+        fleetOpsRecentScheduleItem(['duration' => 180, 'start_at' => '2026-07-17 08:00:00']),
+    ]);
+
+    $overLimit = collect([
+        fleetOpsRecentScheduleItem(['duration' => 600, 'start_at' => '2026-07-18 08:00:00']),
+        fleetOpsRecentScheduleItem(['duration' => 120, 'start_at' => '2026-07-17 08:00:00']),
+    ]);
+
+    $weeklyOverLimit = collect([
+        fleetOpsRecentScheduleItem(['duration' => 4200, 'start_at' => '2026-07-18 08:00:00']),
+        fleetOpsRecentScheduleItem(['duration' => 120, 'start_at' => '2026-07-01 08:00:00']),
+    ]);
+
+    expect(invokeFleetOpsHosConstraint($constraint, 'check11HourDrivingLimit', [$current, $withinLimit]))->toBeTrue()
+        ->and(invokeFleetOpsHosConstraint($constraint, 'check11HourDrivingLimit', [$current, $overLimit]))->toBeFalse()
+        ->and(invokeFleetOpsHosConstraint($constraint, 'check60_70HourWeeklyLimit', [$current, $withinLimit]))->toBeTrue()
+        ->and(invokeFleetOpsHosConstraint($constraint, 'check60_70HourWeeklyLimit', [$current, $weeklyOverLimit]))->toBeFalse();
+});
+
+test('hos constraint handles duty windows and thirty minute break requirements', function () {
+    $constraint = new HOSConstraint();
+    $current    = fleetOpsScheduleItem([
+        'duration'       => 120,
+        'start_at'       => '2026-07-19 12:00:00',
+        'end_at'         => '2026-07-19 14:00:00',
+        'break_start_at' => null,
+        'break_end_at'   => null,
+    ]);
+
+    $recentWithBreak = collect([
+        fleetOpsRecentScheduleItem([
+            'duration'       => 300,
+            'start_at'       => '2026-07-19 05:00:00',
+            'break_start_at' => '2026-07-19 08:00:00',
+            'break_end_at'   => '2026-07-19 08:30:00',
+        ]),
+    ]);
+
+    $recentWithoutBreak = collect([
+        fleetOpsRecentScheduleItem([
+            'duration'       => 420,
+            'start_at'       => '2026-07-19 05:00:00',
+            'break_start_at' => null,
+            'break_end_at'   => null,
+        ]),
+    ]);
+
+    $currentWithBreak = fleetOpsScheduleItem([
+        'duration'       => 120,
+        'start_at'       => '2026-07-19 12:00:00',
+        'end_at'         => '2026-07-19 14:00:00',
+        'break_start_at' => '2026-07-19 12:30:00',
+        'break_end_at'   => '2026-07-19 13:00:00',
+    ]);
+
+    expect(invokeFleetOpsHosConstraint($constraint, 'check14HourDutyWindow', [$current, collect()]))->toBeTrue()
+        ->and(invokeFleetOpsHosConstraint($constraint, 'check30MinuteBreak', [$current, $recentWithBreak]))->toBeTrue()
+        ->and(invokeFleetOpsHosConstraint($constraint, 'check30MinuteBreak', [$current, $recentWithoutBreak]))->toBeFalse()
+        ->and(invokeFleetOpsHosConstraint($constraint, 'check30MinuteBreak', [$currentWithBreak, $recentWithoutBreak]))->toBeTrue();
+});