@fleetbase/fleetops-engine 0.6.58 → 0.6.59

package/server/tests/Unit/Integrations/LalamoveResponseHandlingTest.php

@@ -0,0 +1,58 @@
+<?php
+
+use Fleetbase\FleetOps\Integrations\Lalamove\Lalamove;
+use GuzzleHttp\Client;
+use GuzzleHttp\Handler\MockHandler;
+use GuzzleHttp\HandlerStack;
+use GuzzleHttp\Psr7\Response;
+
+/**
+ * Covers how the Lalamove client interprets API responses: an `errors` key
+ * raises the integration exception, a `data` key is unwrapped, and anything
+ * else is handed back untouched. The Guzzle client is swapped for a mock so
+ * no request leaves the process.
+ */
+function fleetopsLalamoveWithResponses(array $responses): Lalamove
+{
+    $lalamove = new Lalamove('key-1', 'secret-1', true, 'SG');
+
+    $stack  = HandlerStack::create(new MockHandler($responses));
+    $client = new Client(['handler' => $stack, 'base_uri' => 'https://rest.sandbox.lalamove.com']);
+
+    $reflection = new ReflectionProperty(Lalamove::class, 'client');
+    $reflection->setAccessible(true);
+    $reflection->setValue($lalamove, $client);
+
+    return $lalamove;
+}
+
+test('order creation unwraps data and surfaces api errors', function () {
+    // A `data` envelope is unwrapped for the caller
+    $withData = fleetopsLalamoveWithResponses([
+        new Response(200, [], json_encode(['data' => ['id' => 'lalamove-order-1', 'status' => 'ASSIGNING_DRIVER']])),
+    ]);
+    $created = $withData->createOrder('quotation-1', ['name' => 'Sender', 'phone' => '+6591234567'], []);
+    expect($created->id)->toBe('lalamove-order-1');
+
+    // A response carrying neither errors nor data is returned as-is
+    $bare = fleetopsLalamoveWithResponses([
+        new Response(200, [], json_encode(['acknowledged' => true])),
+    ]);
+    expect($bare->createOrder('quotation-2', ['name' => 'Sender', 'phone' => '+6591234567'], [])->acknowledged)->toBeTrue();
+
+    // An `errors` key raises the integration exception naming the method
+    $withErrors = fleetopsLalamoveWithResponses([
+        new Response(200, [], json_encode(['errors' => [['id' => 'ERR_INVALID_QUOTATION', 'message' => 'Quotation expired']]])),
+    ]);
+    expect(fn () => $withErrors->createOrder('quotation-3', ['name' => 'Sender', 'phone' => '+6591234567'], []))
+        ->toThrow(Fleetbase\FleetOps\Exceptions\IntegratedVendorException::class);
+});
+
+test('webhook registration returns bare responses untouched', function () {
+    // setWebhook shares the same response handling as order creation
+    $bare = fleetopsLalamoveWithResponses([
+        new Response(200, [], json_encode(['acknowledged' => true])),
+    ]);
+
+    expect($bare->setWebhook('https://hooks.example.test/lalamove')->acknowledged)->toBeTrue();
+});

package/server/tests/Unit/Jobs/GeofenceDwellAndBulkNotifyTest.php

@@ -0,0 +1,183 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Controllers\Api\v1\NavigatorController;
+use Fleetbase\FleetOps\Jobs\CheckGeofenceDwell;
+use Fleetbase\FleetOps\Jobs\NotifyBulkAssignedDriver;
+use Fleetbase\FleetOps\Models\Customer;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+/**
+ * Covers the CheckGeofenceDwell job branches, the NotifyBulkAssignedDriver
+ * job, the Customer model type scoping and id normalization, and the public
+ * navigator driver-onboard settings endpoint against an in-memory SQLite
+ * fixture.
+ */
+if (!function_exists('Fleetbase\FleetOps\Jobs\event')) {
+    eval('namespace Fleetbase\FleetOps\Jobs; function event($event = null) { \FleetOpsDwellRecorder::$events[] = $event; return $event; }');
+}
+
+if (!function_exists('logger')) {
+    function logger()
+    {
+        return app('log');
+    }
+}
+
+class FleetOpsDwellRecorder
+{
+    public static array $events = [];
+}
+
+function fleetopsDwellBoot(): 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');
+
+    $schema = $connection->getSchemaBuilder();
+    $tables = [
+        'driver_geofence_states'  => ['driver_uuid', 'geofence_uuid', 'geofence_type', 'is_inside', 'entered_at'],
+        'vehicle_geofence_states' => ['vehicle_uuid', 'geofence_uuid', 'geofence_type', 'is_inside', 'entered_at'],
+        'drivers'                 => ['uuid', 'public_id', 'company_uuid', 'user_uuid'],
+        'vehicles'                => ['uuid', 'public_id', 'company_uuid'],
+        'users'                   => ['uuid', 'public_id', 'company_uuid'],
+        'zones'                   => ['uuid', 'public_id', 'company_uuid', 'name', 'service_area_uuid'],
+        'service_areas'           => ['uuid', 'public_id', 'company_uuid', 'name'],
+        'orders'                  => ['uuid', 'public_id', 'company_uuid', 'driver_assigned_uuid', 'status'],
+        'contacts'                => ['uuid', 'public_id', 'company_uuid', 'name', 'type'],
+        'companies'               => ['uuid', 'public_id', 'name'],
+        'settings'                => ['key', 'value'],
+    ];
+    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']);
+    FleetOpsDwellRecorder::$events = [];
+
+    return $connection;
+}
+
+test('dwell check fires events only while the subject remains inside', function () {
+    $connection = fleetopsDwellBoot();
+    $connection->table('driver_geofence_states')->insert([
+        'driver_uuid'   => 'driver-1',
+        'geofence_uuid' => 'zone-1',
+        'geofence_type' => 'zone',
+        'is_inside'     => '1',
+        'entered_at'    => now()->subMinutes(20)->toDateTimeString(),
+    ]);
+    $connection->table('drivers')->insert(['uuid' => 'driver-1', 'company_uuid' => 'company-1']);
+    $connection->table('zones')->insert(['uuid' => 'zone-1', 'company_uuid' => 'company-1', 'name' => 'North Zone']);
+
+    (new CheckGeofenceDwell('driver-1', 'zone-1', 'zone'))->handle();
+    expect(FleetOpsDwellRecorder::$events)->toHaveCount(1);
+
+    // Exited subjects do not fire dwell events
+    FleetOpsDwellRecorder::$events = [];
+    (new CheckGeofenceDwell('driver-2', 'zone-1', 'zone'))->handle();
+    expect(FleetOpsDwellRecorder::$events)->toBe([]);
+});
+
+test('dwell check skips missing subjects and geofences with warnings', function () {
+    $connection = fleetopsDwellBoot();
+    $connection->table('driver_geofence_states')->insert([
+        'driver_uuid'   => 'driver-ghost',
+        'geofence_uuid' => 'zone-1',
+        'geofence_type' => 'zone',
+        'is_inside'     => '1',
+        'entered_at'    => now()->toDateTimeString(),
+    ]);
+
+    // Missing subject
+    (new CheckGeofenceDwell('driver-ghost', 'zone-1', 'zone'))->handle();
+    expect(FleetOpsDwellRecorder::$events)->toBe([]);
+
+    // Present vehicle subject but missing service-area geofence
+    $connection->table('vehicle_geofence_states')->insert([
+        'vehicle_uuid'  => 'vehicle-1',
+        'geofence_uuid' => 'sa-missing',
+        'geofence_type' => 'service_area',
+        'is_inside'     => '1',
+        'entered_at'    => now()->toDateTimeString(),
+    ]);
+    $connection->table('vehicles')->insert(['uuid' => 'vehicle-1', 'company_uuid' => 'company-1']);
+
+    (new CheckGeofenceDwell('vehicle-1', 'sa-missing', 'service_area', 'vehicle'))->handle();
+    expect(FleetOpsDwellRecorder::$events)->toBe([]);
+});
+
+test('bulk driver notification assigns and notifies matched orders', function () {
+    $connection = fleetopsDwellBoot();
+    $connection->table('users')->insert(['uuid' => 'user-1', 'company_uuid' => 'company-1']);
+    $connection->table('drivers')->insert(['uuid' => 'driver-1', 'company_uuid' => 'company-1', 'user_uuid' => 'user-1']);
+    $connection->table('orders')->insert(['uuid' => 'order-1', 'company_uuid' => 'company-1', 'status' => 'created']);
+
+    // Notification delivery is unavailable in the harness; the failure log
+    // seam captures each attempted order.
+    (new NotifyBulkAssignedDriver(['order-1'], 'driver-1'))->handle();
+    expect(true)->toBeTrue();
+
+    // Missing drivers exit without touching orders
+    (new NotifyBulkAssignedDriver(['order-1'], 'driver-missing'))->handle();
+    expect(true)->toBeTrue();
+});
+
+test('customer model scopes to customer contacts and normalizes public ids', function () {
+    $connection = fleetopsDwellBoot();
+    $connection->table('contacts')->insert([
+        ['uuid' => 'contact-1', 'public_id' => 'contact_abc', 'company_uuid' => 'company-1', 'name' => 'Customer A', 'type' => 'customer'],
+        ['uuid' => 'contact-2', 'public_id' => 'contact_def', 'company_uuid' => 'company-1', 'name' => 'Plain Contact', 'type' => 'contact'],
+    ]);
+
+    // Contact defines an instance-level count(); go through query() for the
+    // aggregate so the global type scope is exercised.
+    expect(Customer::query()->count())->toBe(1);
+
+    $byCustomerId = Customer::findFromCustomerId('customer_abc');
+    expect($byCustomerId)->toBeInstanceOf(Customer::class)
+        ->and($byCustomerId->uuid)->toBe('contact-1');
+
+    expect(Customer::findFromCustomerId('contact_abc')?->uuid)->toBe('contact-1')
+        ->and(Customer::findFromCustomerId('customer_missing'))->toBeNull();
+});
+
+test('navigator driver onboard settings endpoint resolves company settings', function () {
+    $connection = fleetopsDwellBoot();
+    $connection->table('companies')->insert(['uuid' => 'company-1', 'public_id' => 'company_test', 'name' => 'Acme']);
+    $connection->table('settings')->insert(['key' => 'fleet-ops.driver-onboard-settings.company-1', 'value' => json_encode(['enabled' => true])]);
+
+    $response = (new NavigatorController())->getDriverOnboardSettings('company_test');
+    expect($response->getData(true)['driverOnboardSettings'])->not->toBeEmpty();
+
+    // Companies without settings fall back to an empty array
+    $connection->table('companies')->insert(['uuid' => 'company-2', 'public_id' => 'company_two', 'name' => 'Beta']);
+    $empty = (new NavigatorController())->getDriverOnboardSettings('company_two');
+    expect($empty->getData(true)['driverOnboardSettings'])->toBe([]);
+});

package/server/tests/Unit/Jobs/ReplayPositionsTest.php

@@ -0,0 +1,57 @@
+<?php
+
+use Fleetbase\FleetOps\Jobs\ReplayPositions;
+use Fleetbase\FleetOps\Jobs\SendPositionReplay;
+use Fleetbase\FleetOps\Models\Position;
+use Fleetbase\TestSupport\DispatchRecorder;
+
+/**
+ * Covers the ReplayPositions job: relative offset computation from the first
+ * position, per-position replay dispatching with speed scaling, and the
+ * completion log.
+ */
+function fleetopsReplayBoot(): void
+{
+    $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);
+}
+
+function fleetopsReplayPosition(string $createdAt): Position
+{
+    $position = new Position();
+    $position->setRawAttributes(['uuid' => 'position-' . md5($createdAt), 'created_at' => $createdAt], true);
+
+    return $position;
+}
+
+test('handle dispatches a replay job per position with scaled offsets', function () {
+    fleetopsReplayBoot();
+    DispatchRecorder::$dispatched = [];
+
+    $positions = collect([
+        fleetopsReplayPosition('2026-08-01 10:00:00'),
+        fleetopsReplayPosition('2026-08-01 10:00:30'),
+        fleetopsReplayPosition('2026-08-01 10:01:00'),
+    ]);
+
+    $job = new ReplayPositions($positions, 'channel-1', 2.0, 'subject-1');
+    $job->handle();
+
+    expect(DispatchRecorder::$dispatched)->toHaveCount(3)
+        ->and(DispatchRecorder::$dispatched[0]['job'])->toBe(SendPositionReplay::class)
+        ->and(DispatchRecorder::$dispatched[0]['arguments'][0])->toBe('channel-1')
+        ->and(DispatchRecorder::$dispatched[1]['arguments'][3])->toBe('subject-1');
+});
+
+test('constructor clamps the replay speed to a minimum', function () {
+    fleetopsReplayBoot();
+    DispatchRecorder::$dispatched = [];
+    $positions                    = collect([fleetopsReplayPosition('2026-08-01 10:00:00')]);
+
+    $job = new ReplayPositions($positions, 'channel-1', 0.0);
+    $job->handle();
+
+    expect(DispatchRecorder::$dispatched)->toHaveCount(1);
+});

package/server/tests/Unit/Jobs/SimulateWaypointReachedTest.php

@@ -0,0 +1,92 @@
+<?php
+
+if (!function_exists('app')) {
+    function app($abstract = null)
+    {
+        return $abstract ? Illuminate\Container\Container::getInstance()->make($abstract) : Illuminate\Container\Container::getInstance();
+    }
+}
+
+if (!function_exists('Fleetbase\Traits\config')) {
+    eval('namespace Fleetbase\Traits; function config($key = null, $default = null) { return $key === "api.cache.enabled" ? false : $default; }');
+}
+
+if (!trait_exists('Illuminate\Foundation\Bus\Dispatchable')) {
+    eval('namespace Illuminate\Foundation\Bus; trait Dispatchable {}');
+}
+
+if (!function_exists('Fleetbase\FleetOps\Jobs\event')) {
+    eval('namespace Fleetbase\FleetOps\Jobs; function event($event = null, $payload = [], $halt = false) { $GLOBALS["fleetopsUnitSimulateWaypointReachedEvents"][] = $event; return [$event]; }');
+}
+
+if (!class_exists('Illuminate\Foundation\Auth\User')) {
+    class_alias(Illuminate\Database\Eloquent\Model::class, 'Illuminate\Foundation\Auth\User');
+}
+
+use Fleetbase\FleetOps\Events\DriverSimulatedLocationChanged;
+use Fleetbase\FleetOps\Jobs\SimulateWaypointReached;
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\LaravelMysqlSpatial\Types\Point;
+
+class FleetOpsUnitWaypointPointWithHeading extends Point
+{
+    public int $heading = 270;
+}
+
+function fleetopsUnitSimulatedDriver(): Driver
+{
+    $driver = new Driver();
+    $driver->setRawAttributes([
+        'uuid'        => 'driver-uuid',
+        'public_id'   => 'driver-public',
+        'internal_id' => 'driver-internal',
+        'altitude'    => 44,
+        'heading'     => 90,
+        'speed'       => 35,
+    ], true);
+    $driver->setRelation('user', (object) [
+        'name'  => 'Test Driver',
+        'phone' => '+15555550000',
+    ]);
+
+    return $driver;
+}
+
+function fleetopsUnitCaptureWaypointEvents(): void
+{
+    $GLOBALS['fleetopsUnitSimulateWaypointReachedEvents'] = [];
+}
+
+test('simulate waypoint reached dispatches simulated location event with waypoint heading', function () {
+    fleetopsUnitCaptureWaypointEvents();
+
+    $waypoint = new FleetOpsUnitWaypointPointWithHeading(1.30, 103.80);
+    $job      = new SimulateWaypointReached(fleetopsUnitSimulatedDriver(), $waypoint, ['speed' => 42]);
+
+    $job->handle();
+
+    $event = $GLOBALS['fleetopsUnitSimulateWaypointReachedEvents'][0] ?? null;
+
+    expect($event)->toBeInstanceOf(DriverSimulatedLocationChanged::class)
+        ->and($event->location)->toBe($waypoint)
+        ->and($event->heading)->toBe(270)
+        ->and($event->speed)->toBe(42)
+        ->and($event->additionalData)->toBe(['speed' => 42, 'heading' => 270]);
+});
+
+test('simulate waypoint reached keeps provided data when waypoint has no heading', function () {
+    fleetopsUnitCaptureWaypointEvents();
+
+    $waypoint = new Point(1.31, 103.81);
+    $job      = new SimulateWaypointReached(fleetopsUnitSimulatedDriver(), $waypoint, ['speed' => 24]);
+
+    $job->handle();
+
+    $event = $GLOBALS['fleetopsUnitSimulateWaypointReachedEvents'][0] ?? null;
+
+    expect($event)->toBeInstanceOf(DriverSimulatedLocationChanged::class)
+        ->and($event->location)->toBe($waypoint)
+        ->and($event->heading)->toBe(90)
+        ->and($event->speed)->toBe(24)
+        ->and($event->additionalData)->toBe(['speed' => 24]);
+});

package/server/tests/Unit/Listeners/HandleGeofenceEnteredTest.php

@@ -0,0 +1,256 @@
+<?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\Events\GeofenceEntered;
+use Fleetbase\FleetOps\Flow\Activity;
+use Fleetbase\FleetOps\Listeners\HandleGeofenceEntered;
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\GeofenceEventLog;
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Models\TrackingStatus;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\LaravelMysqlSpatial\Types\Point;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+class FleetOpsHandleGeofenceEnteredDriverFake extends Driver
+{
+    public ?Order $currentOrder = null;
+
+    public function getAttribute($key)
+    {
+        if ($key === 'vehicle') {
+            return $this->relations['vehicle'] ?? null;
+        }
+
+        if (in_array($key, ['uuid', 'public_id', 'company_uuid', 'name', 'phone'], true)) {
+            return $this->attributes[$key] ?? null;
+        }
+
+        return parent::getAttribute($key);
+    }
+
+    public function getCurrentOrder(): ?Order
+    {
+        return $this->currentOrder;
+    }
+}
+
+class FleetOpsHandleGeofenceEnteredVehicleFake extends Vehicle
+{
+    public function getAttribute($key)
+    {
+        if ($key === 'display_name') {
+            return $this->attributes['display_name'] ?? $this->attributes['name'] ?? null;
+        }
+
+        if (in_array($key, ['display_name', 'name', 'plate_number', 'uuid', 'public_id', 'company_uuid'], true)) {
+            return $this->attributes[$key] ?? null;
+        }
+
+        return parent::getAttribute($key);
+    }
+
+    public function loadMissing($relations)
+    {
+        return $this;
+    }
+}
+
+class FleetOpsHandleGeofenceEnteredOrderFake extends Order
+{
+    public array $calls        = [];
+    public bool $throwOnStatus = false;
+
+    public function setStatus(?string $status, $andSave = true)
+    {
+        if ($this->throwOnStatus) {
+            throw new RuntimeException('status failed');
+        }
+
+        $this->calls[]              = ['setStatus', $status, $andSave];
+        $this->attributes['status'] = $status;
+
+        return $this;
+    }
+
+    public function createActivity(Activity $activity, $location = [], $proof = null): TrackingStatus
+    {
+        $this->calls[] = ['createActivity', $activity, $location, $proof];
+
+        return new TrackingStatus();
+    }
+}
+
+function fleetopsHandleGeofenceEnteredConnection(): SQLiteConnection
+{
+    $pdo        = new PDO('sqlite::memory:');
+    $connection = new SQLiteConnection($pdo, 'default');
+    $connection->statement('create table geofence_events_log (uuid varchar(64) primary key, company_uuid varchar(64), driver_uuid varchar(64) null, vehicle_uuid varchar(64) null, order_uuid varchar(64) null, subject_uuid varchar(64) null, subject_type varchar(255) null, subject_name varchar(255) null, geofence_uuid varchar(64), geofence_type varchar(64), geofence_name varchar(255) null, event_type varchar(64), latitude numeric null, longitude numeric null, speed_kmh numeric null, dwell_duration_minutes integer null, occurred_at datetime null, created_at datetime null, updated_at datetime null)');
+
+    $resolver = new ConnectionResolver([
+        'default' => $connection,
+    ]);
+    $resolver->setDefaultConnection('default');
+    EloquentModel::setConnectionResolver($resolver);
+    GeofenceEventLog::setConnectionResolver($resolver);
+
+    return $connection;
+}
+
+function fleetopsEnteredDriver(?Order $order = null): FleetOpsHandleGeofenceEnteredDriverFake
+{
+    $driver = new FleetOpsHandleGeofenceEnteredDriverFake();
+    $driver->setRawAttributes([
+        'uuid'         => 'driver-uuid',
+        'public_id'    => 'driver-public',
+        'company_uuid' => 'company-uuid',
+        'name'         => 'Jane Driver',
+        'phone'        => '+15551230000',
+    ], true);
+    $driver->setRelation('vehicle', null);
+    $driver->currentOrder = $order;
+
+    return $driver;
+}
+
+function fleetopsEnteredOrder(mixed $payload): FleetOpsHandleGeofenceEnteredOrderFake
+{
+    $order = new FleetOpsHandleGeofenceEnteredOrderFake();
+    $order->setRawAttributes([
+        'uuid'      => 'order-uuid',
+        'public_id' => 'order-public',
+        'status'    => 'dispatched',
+    ], true);
+    $order->setRelation('payload', $payload);
+    $order->setRelation('trackingNumber', (object) ['last_status' => 'dispatched']);
+
+    return $order;
+}
+
+function fleetopsEnteredEvent(Driver|Vehicle $subject, ?object $geofence = null): GeofenceEntered
+{
+    $geofence ??= new class {
+        public string $uuid      = 'zone-uuid';
+        public string $public_id = 'zone-public';
+        public string $name      = 'Destination Zone';
+
+        public function getLatitudeAttribute(): float
+        {
+            return 1.3521;
+        }
+
+        public function getLongitudeAttribute(): float
+        {
+            return 103.8198;
+        }
+    };
+
+    return new GeofenceEntered($subject, $geofence, 'zone', new Point(1.3521, 103.8198));
+}
+
+test('geofence entered listener writes driver entry logs through the public handle path', function () {
+    $connection = fleetopsHandleGeofenceEnteredConnection();
+    $driver     = fleetopsEnteredDriver();
+
+    (new HandleGeofenceEntered())->handle(fleetopsEnteredEvent($driver));
+
+    $log = $connection->table('geofence_events_log')->first();
+
+    expect(session('company'))->toBe('company-uuid')
+        ->and($log->company_uuid)->toBe('company-uuid')
+        ->and($log->driver_uuid)->toBe('driver-uuid')
+        ->and($log->vehicle_uuid)->toBeNull()
+        ->and($log->order_uuid)->toBeNull()
+        ->and($log->subject_uuid)->toBe('driver-uuid')
+        ->and($log->subject_type)->toBe('driver')
+        ->and($log->subject_name)->toBe('Jane Driver')
+        ->and($log->geofence_uuid)->toBe('zone-uuid')
+        ->and($log->geofence_type)->toBe('zone')
+        ->and($log->event_type)->toBe('entered')
+        ->and((float) $log->latitude)->toBe(1.3521)
+        ->and((float) $log->longitude)->toBe(103.8198);
+});
+
+test('geofence entered listener writes vehicle entry logs with current order context', function () {
+    $connection = fleetopsHandleGeofenceEnteredConnection();
+    $order      = fleetopsEnteredOrder(new class {
+        public function getPickupOrCurrentWaypoint(): mixed
+        {
+            return null;
+        }
+    });
+    $driver  = fleetopsEnteredDriver($order);
+    $vehicle = new FleetOpsHandleGeofenceEnteredVehicleFake();
+    $vehicle->setRawAttributes([
+        'uuid'         => 'vehicle-uuid',
+        'public_id'    => 'vehicle-public',
+        'company_uuid' => 'company-uuid',
+        'name'         => 'Dock Van',
+        'plate_number' => 'SG-202',
+    ], true);
+    $vehicle->setRelation('driver', $driver);
+    $driver->setRelation('vehicle', $vehicle);
+
+    (new HandleGeofenceEntered())->handle(fleetopsEnteredEvent($vehicle));
+
+    $log = $connection->table('geofence_events_log')->first();
+
+    expect($log->driver_uuid)->toBe('driver-uuid')
+        ->and($log->vehicle_uuid)->toBe('vehicle-uuid')
+        ->and($log->order_uuid)->toBe('order-uuid')
+        ->and($log->subject_uuid)->toBe('vehicle-uuid')
+        ->and($log->subject_type)->toBe('vehicle')
+        ->and($log->subject_name)->toBe('Dock Van');
+});
+
+test('geofence entered arrival handles destination and status failures', function () {
+    $listener = new HandleGeofenceEntered();
+    $arrival  = new ReflectionMethod(HandleGeofenceEntered::class, 'handleOrderArrival');
+    $arrival->setAccessible(true);
+
+    $driver = fleetopsEnteredDriver();
+    $event  = fleetopsEnteredEvent($driver);
+
+    $destinationFailure = fleetopsEnteredOrder(new class {
+        public function getPickupOrCurrentWaypoint(): mixed
+        {
+            throw new RuntimeException('destination failed');
+        }
+    });
+    $arrival->invoke($listener, $driver, $event->geofence, $destinationFailure, $event);
+
+    $placeFailure = fleetopsEnteredOrder(new class {
+        public function getPickupOrCurrentWaypoint(): object
+        {
+            return new class {
+                public function getPlace(): mixed
+                {
+                    throw new RuntimeException('place failed');
+                }
+            };
+        }
+    });
+    $arrival->invoke($listener, $driver, $event->geofence, $placeFailure, $event);
+
+    $statusFailure = fleetopsEnteredOrder(new class {
+        public function getPickupOrCurrentWaypoint(): object
+        {
+            return (object) ['place' => (object) ['location' => new Point(1.3521, 103.8198)]];
+        }
+    });
+    $statusFailure->throwOnStatus = true;
+    $arrival->invoke($listener, $driver, $event->geofence, $statusFailure, $event);
+
+    expect($destinationFailure->calls)->toBe([])
+        ->and($placeFailure->calls)->toBe([])
+        ->and($statusFailure->calls)->toBe([]);
+});