@fleetbase/fleetops-engine 0.6.58 → 0.6.60

package/server/tests/DriverFilterExecutionTest.php

@@ -0,0 +1,263 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Filter\DriverFilter;
+use Illuminate\Http\Request;
+use Illuminate\Support\Str;
+
+class FleetOpsRecordingDriverFilterBuilder
+{
+    public array $calls = [];
+
+    public function where($column, ...$args)
+    {
+        $this->calls[] = ['where', $column, $args];
+        $this->invokeNested($column);
+
+        return $this;
+    }
+
+    public function orWhere($column, ...$args)
+    {
+        $this->calls[] = ['orWhere', $column, $args];
+        $this->invokeNested($column);
+
+        return $this;
+    }
+
+    public function whereHas($relation, ?Closure $callback = null)
+    {
+        $nested        = new self();
+        $this->calls[] = ['whereHas', $relation, $nested];
+        $callback?->call($this, $nested);
+
+        return $this;
+    }
+
+    public function orWhereHas($relation, ?Closure $callback = null)
+    {
+        $nested        = new self();
+        $this->calls[] = ['orWhereHas', $relation, $nested];
+        $callback?->call($this, $nested);
+
+        return $this;
+    }
+
+    public function searchWhere($columns, $query)
+    {
+        $this->calls[] = ['searchWhere', $columns, $query];
+
+        return $this;
+    }
+
+    public function search($query)
+    {
+        $this->calls[] = ['search', $query];
+
+        return $this;
+    }
+
+    public function __call($method, $arguments)
+    {
+        $this->calls[] = [$method, ...$arguments];
+
+        foreach ($arguments as $argument) {
+            $this->invokeNested($argument);
+        }
+
+        return $this;
+    }
+
+    public function called(string $method): bool
+    {
+        return !empty($this->methodCalls($method));
+    }
+
+    public function methodCalls(string $method): array
+    {
+        return array_values(array_filter($this->calls, fn ($call) => $call[0] === $method));
+    }
+
+    private function invokeNested($value): void
+    {
+        if (!$value instanceof Closure) {
+            return;
+        }
+
+        $reflection = new ReflectionFunction($value);
+        if ($reflection->getNumberOfParameters() > 0) {
+            $value($this);
+
+            return;
+        }
+
+        $value();
+    }
+}
+
+function fleetopsDriverFilter(FleetOpsRecordingDriverFilterBuilder $builder, array $query = []): DriverFilter
+{
+    $request = Request::create('/int/v1/drivers', 'GET', $query);
+    $session = app('session.store');
+    $session->put('company', 'company_test');
+    $request->setLaravelSession($session);
+
+    $filter     = new DriverFilter($request);
+    $reflection = new ReflectionClass($filter);
+    $property   = $reflection->getParentClass()->getProperty('builder');
+    $property->setAccessible(true);
+    $property->setValue($filter, $builder);
+
+    return $filter;
+}
+
+test('driver filter applies internal public and text search scopes', function () {
+    $builder = new FleetOpsRecordingDriverFilterBuilder();
+    $filter  = fleetopsDriverFilter($builder);
+
+    $filter->queryForInternal();
+    $filter->queryForPublic();
+    $filter->query('driver needle');
+    $filter->internalId('driver-internal');
+    $filter->name('Jane Driver');
+    $filter->publicId('driver_public');
+
+    expect($builder->called('where'))->toBeTrue()
+        ->and($builder->called('whereHas'))->toBeTrue()
+        ->and($builder->called('orWhereHas'))->toBeTrue()
+        ->and($builder->called('searchWhere'))->toBeTrue();
+});
+
+test('driver filter assignment and identity filters execute uuid and public branches', function () {
+    $builder = new FleetOpsRecordingDriverFilterBuilder();
+    $filter  = fleetopsDriverFilter($builder);
+    $uuid    = (string) Str::uuid();
+
+    $filter->facilitator('vendor_uuid');
+    $filter->vendor('vendor_uuid');
+    $filter->vehicle('unassigned');
+    $filter->vehicle($uuid);
+    $filter->vehicle('vehicle_public');
+    $filter->driversLicenseNumber('DL-123');
+    $filter->phone('+15551112222');
+    $filter->country('SG,MY');
+    $filter->country('MN');
+    $filter->status('available,offline');
+    $filter->fleet('fleet_uuid');
+
+    expect($builder->called('whereNull'))->toBeTrue()
+        ->and($builder->called('where'))->toBeTrue()
+        ->and($builder->called('whereHas'))->toBeTrue()
+        ->and($builder->called('whereIn'))->toBeTrue()
+        ->and($builder->called('searchWhere'))->toBeTrue();
+});
+
+test('driver filter date and nearby coordinate filters execute query operations', function () {
+    $builder = new FleetOpsRecordingDriverFilterBuilder();
+    $filter  = fleetopsDriverFilter($builder, ['radius' => 1200]);
+
+    $filter->createdAt('2026-01-01');
+    $filter->updatedAt(['2026-01-01', '2026-01-31']);
+    $filter->nearby('1.3000,103.8000');
+
+    expect($builder->called('whereDate'))->toBeTrue()
+        ->and($builder->called('whereBetween'))->toBeTrue()
+        ->and($builder->called('whereNotNull'))->toBeTrue()
+        ->and($builder->called('whereRaw'))->toBeTrue()
+        ->and($builder->called('distanceSphere'))->toBeTrue()
+        ->and($builder->called('distanceSphereValue'))->toBeTrue();
+});
+
+test('driver filter covers alternate date branches company radius and address nearby', function () {
+    // Array created-at ranges and scalar updated-at dates hit the inverse branches
+    $builder = new FleetOpsRecordingDriverFilterBuilder();
+    $filter  = fleetopsDriverFilter($builder, ['radius' => 900]);
+    $filter->createdAt(['2026-01-01', '2026-01-31']);
+    $filter->updatedAt('2026-01-15');
+    expect($builder->called('whereBetween'))->toBeTrue()
+        ->and($builder->called('whereDate'))->toBeTrue();
+
+    // Without a radius input the company option and hard default provide distances
+    $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);
+    app()->instance('db', new class($connection) {
+        public function __construct(public Illuminate\Database\SQLiteConnection $c)
+        {
+        }
+
+        public function connection($name = null)
+        {
+            return $this->c;
+        }
+
+        public function __call($method, $arguments)
+        {
+            return $this->c->{$method}(...$arguments);
+        }
+    });
+    Illuminate\Support\Facades\DB::clearResolvedInstance('db');
+    $schema = $connection->getSchemaBuilder();
+    $schema->create('companies', function ($blueprint) {
+        $blueprint->increments('id');
+        foreach (['uuid', 'public_id', 'name', 'options'] as $column) {
+            $blueprint->string($column)->nullable();
+        }
+        $blueprint->timestamps();
+        $blueprint->timestamp('deleted_at')->nullable();
+    });
+    $schema->create('places', function ($blueprint) {
+        $blueprint->increments('id');
+        foreach (['uuid', 'public_id', 'company_uuid', 'name', 'street1', 'city', 'country', 'location', 'meta', '_key'] as $column) {
+            $blueprint->string($column)->nullable();
+        }
+        $blueprint->timestamps();
+        $blueprint->timestamp('deleted_at')->nullable();
+    });
+    $connection->table('companies')->insert(['uuid' => 'company_test', 'name' => 'Filter Co', 'options' => json_encode(['fleetops' => ['adhoc_distance' => 2500]])]);
+
+    // No radius, no company: the hard 6000m default applies
+    session(['company' => null]);
+    $defaultBuilder = new FleetOpsRecordingDriverFilterBuilder();
+    $defaultFilter  = fleetopsDriverFilter($defaultBuilder, []);
+    $defaultFilter->nearby('1.3000,103.8000');
+    expect($defaultBuilder->called('distanceSphere'))->toBeTrue();
+
+    session(['company' => 'company_test']);
+    $companyBuilder = new FleetOpsRecordingDriverFilterBuilder();
+    $companyFilter  = fleetopsDriverFilter($companyBuilder, []);
+    $companyFilter->nearby('1.3000,103.8000');
+    expect($companyBuilder->called('distanceSphere'))->toBeTrue();
+
+    // Address-string nearby lookups resolve places and add distance queries
+    $wkbPoint = pack('V', 0) . pack('C', 1) . pack('V', 1) . pack('d', 103.8) . pack('d', 1.3);
+    $connection->table('places')->insert(['uuid' => 'place-filter-1', 'company_uuid' => 'company_test', 'name' => 'Filter Depot', 'street1' => 'Filter Depot Road', 'location' => $wkbPoint]);
+    $address = Geocoder\Provider\GoogleMaps\Model\GoogleAddress::createFromArray([
+        'providedBy' => 'google',
+        'latitude'   => 1.3,
+        'longitude'  => 103.8,
+        'streetName' => 'Filter Depot Road',
+        'locality'   => 'Singapore',
+        'country'    => 'Singapore',
+    ]);
+    app()->instance('fleetops.geocoder', new class($address) {
+        public function __construct(public $address)
+        {
+        }
+
+        public function geocodeQuery($query)
+        {
+            return new Geocoder\Model\AddressCollection([$this->address]);
+        }
+
+        public function reverseQuery($query)
+        {
+            return new Geocoder\Model\AddressCollection([$this->address]);
+        }
+    });
+    $addressBuilder = new FleetOpsRecordingDriverFilterBuilder();
+    $addressFilter  = fleetopsDriverFilter($addressBuilder, ['radius' => 800]);
+    $addressFilter->nearby('Filter Depot');
+    expect($addressBuilder->called('distanceSphere'))->toBeTrue()
+        ->and($addressBuilder->called('distanceSphereValue'))->toBeTrue();
+});

package/server/tests/DriverGeofenceProcessingTest.php

@@ -0,0 +1,153 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Controllers\Api\v1\DriverController;
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\LaravelMysqlSpatial\Types\Point;
+use Illuminate\Support\Carbon;
+use Illuminate\Support\Facades\DB;
+
+class FleetOpsDbRecorder
+{
+    public array $queries;
+    public array $tables = [];
+
+    public function __construct(FleetOpsDbQueryRecorder ...$queries)
+    {
+        $this->queries = $queries;
+    }
+
+    public function table(string $table): FleetOpsDbQueryRecorder
+    {
+        $this->tables[] = $table;
+
+        return array_shift($this->queries) ?? new FleetOpsDbQueryRecorder();
+    }
+}
+
+class FleetOpsDbQueryRecorder
+{
+    public array $wheres  = [];
+    public ?array $upsert = null;
+    public ?array $update = null;
+    public mixed $first   = null;
+
+    public function where(string $column, mixed $value): self
+    {
+        $this->wheres[] = [$column, $value];
+
+        return $this;
+    }
+
+    public function first(): mixed
+    {
+        return $this->first;
+    }
+
+    public function upsert(array $rows, array $uniqueBy, array $update): int
+    {
+        $this->upsert = compact('rows', 'uniqueBy', 'update');
+
+        return 1;
+    }
+
+    public function update(array $payload): int
+    {
+        $this->update = $payload;
+
+        return 1;
+    }
+}
+
+function fleetopsRecordDb(FleetOpsDbQueryRecorder ...$queries): FleetOpsDbRecorder
+{
+    $db = new FleetOpsDbRecorder(...$queries);
+    app()->instance('db', $db);
+    DB::clearResolvedInstance('db');
+
+    return $db;
+}
+
+function fleetopsProcessDriverGeofenceCrossings(Driver $driver, array $crossings): void
+{
+    $controller = new DriverController();
+    $reflection = new ReflectionMethod(DriverController::class, 'processSubjectGeofenceCrossings');
+    $reflection->setAccessible(true);
+
+    $reflection->invoke($controller, $driver, new Point(1.3, 103.8), 'driver_geofence_states', 'driver_uuid', $crossings);
+}
+
+function fleetopsGeofenceDriver(): Driver
+{
+    $driver = new Driver();
+    $driver->setRawAttributes([
+        'uuid'         => 'driver-uuid',
+        'public_id'    => 'driver-public',
+        'company_uuid' => 'company-uuid',
+        'name'         => 'Ada Driver',
+        'phone'        => '+15551234567',
+    ], true);
+    $driver->setRelation('vehicle', null);
+
+    return $driver;
+}
+
+function fleetopsGeofence(array $attributes = []): object
+{
+    return (object) array_merge([
+        'uuid'                    => 'geofence-uuid',
+        'public_id'               => 'geofence-public',
+        'name'                    => 'Depot',
+        'trigger_on_entry'        => true,
+        'trigger_on_exit'         => true,
+        'dwell_threshold_minutes' => 0,
+    ], $attributes);
+}
+
+test('driver geofence processor skips passive entries without state changes', function () {
+    $db = fleetopsRecordDb();
+
+    fleetopsProcessDriverGeofenceCrossings(fleetopsGeofenceDriver(), [
+        [
+            'type'          => 'entered',
+            'geofence'      => fleetopsGeofence([
+                'trigger_on_entry'        => false,
+                'dwell_threshold_minutes' => 0,
+            ]),
+            'geofence_type' => 'zone',
+        ],
+    ]);
+
+    expect($db->tables)->toBeEmpty();
+});
+
+test('driver geofence processor persists exit state with dwell duration inputs', function () {
+    Carbon::setTestNow('2026-01-01 12:12:00');
+
+    $stateQuery        = new FleetOpsDbQueryRecorder();
+    $stateQuery->first = (object) ['entered_at' => Carbon::parse('2026-01-01 12:00:00')];
+    $updateQuery       = new FleetOpsDbQueryRecorder();
+    $db                = fleetopsRecordDb($stateQuery, $updateQuery);
+
+    fleetopsProcessDriverGeofenceCrossings(fleetopsGeofenceDriver(), [
+        [
+            'type'          => 'exited',
+            'geofence'      => fleetopsGeofence(['trigger_on_exit' => false]),
+            'geofence_type' => 'zone',
+        ],
+    ]);
+
+    expect($db->tables)->toBe(['driver_geofence_states', 'driver_geofence_states'])
+        ->and($stateQuery->wheres)->toBe([
+            ['driver_uuid', 'driver-uuid'],
+            ['geofence_uuid', 'geofence-uuid'],
+        ])
+        ->and($updateQuery->wheres)->toBe([
+            ['driver_uuid', 'driver-uuid'],
+            ['geofence_uuid', 'geofence-uuid'],
+        ])
+        ->and($updateQuery->update['is_inside'])->toBeFalse()
+        ->and($updateQuery->update['dwell_job_id'])->toBeNull()
+        ->and($updateQuery->update['exited_at']->equalTo(Carbon::now()))->toBeTrue();
+
+    Carbon::setTestNow();
+});

package/server/tests/DriverResourceSerializationTest.php

@@ -0,0 +1,245 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Resources\v1\Driver as DriverResource;
+use Illuminate\Http\Request;
+use Illuminate\Support\Carbon;
+
+class FleetOpsDriverResourceRouteFixture
+{
+    public function __construct(private string $uri)
+    {
+    }
+
+    public function uri(): string
+    {
+        return $this->uri;
+    }
+}
+
+class FleetOpsDriverResourceFixture implements ArrayAccess
+{
+    public bool $wasRecentlyCreated = false;
+
+    public function __construct(private array $attributes)
+    {
+    }
+
+    public function __get(string $key): mixed
+    {
+        return $this->attributes[$key] ?? null;
+    }
+
+    public function __isset(string $key): bool
+    {
+        return array_key_exists($key, $this->attributes);
+    }
+
+    public function offsetExists(mixed $offset): bool
+    {
+        return array_key_exists((string) $offset, $this->attributes);
+    }
+
+    public function offsetGet(mixed $offset): mixed
+    {
+        return $this->attributes[(string) $offset] ?? null;
+    }
+
+    public function offsetSet(mixed $offset, mixed $value): void
+    {
+        $this->attributes[(string) $offset] = $value;
+    }
+
+    public function offsetUnset(mixed $offset): void
+    {
+        unset($this->attributes[(string) $offset]);
+    }
+
+    public function relationLoaded(string $relationship): bool
+    {
+        return false;
+    }
+
+    public function loadMissing(string $relationship): self
+    {
+        return $this;
+    }
+
+    public function getOriginal(string $key): mixed
+    {
+        return $this->attributes['original'][$key] ?? $this->attributes[$key] ?? null;
+    }
+
+    public function withCustomFields(array $payload): array
+    {
+        return $payload;
+    }
+}
+
+class TestFleetOpsDriverResource extends DriverResource
+{
+    protected function assignedOrdersCount(): int
+    {
+        return 4;
+    }
+
+    protected function currentOrderReference(): ?string
+    {
+        return 'order_current';
+    }
+}
+
+function fleetopsDriverResourceRequest(bool $internal): Request
+{
+    $uri     = $internal ? 'api/int/v1/fleet-ops/drivers/driver_123' : 'api/v1/fleet-ops/drivers/driver_123';
+    $request = Request::create('/' . $uri, 'GET');
+
+    $request->setRouteResolver(fn () => new FleetOpsDriverResourceRouteFixture($uri));
+    app()->instance('request', $request);
+    app()->instance('redis', new class {
+        private string $countryData = '{"currency":"SGD","capital":"Singapore"}';
+
+        public function connection(): self
+        {
+            return $this;
+        }
+
+        public function exists(string $key): bool
+        {
+            return str_starts_with($key, 'countryData:');
+        }
+
+        public function get(string $key): string
+        {
+            return $this->countryData;
+        }
+
+        public function __call(string $method, array $arguments): mixed
+        {
+            return null;
+        }
+    });
+
+    return $request;
+}
+
+function fleetopsDriverResourceFixture(array $overrides = []): FleetOpsDriverResourceFixture
+{
+    return new FleetOpsDriverResourceFixture(array_merge([
+        'id'                             => 77,
+        'uuid'                           => 'driver-uuid',
+        'public_id'                      => 'driver_public',
+        'internal_id'                    => 'DRV-77',
+        'user_uuid'                      => 'user-uuid',
+        'company_uuid'                   => 'company-uuid',
+        'vehicle_uuid'                   => 'vehicle-uuid',
+        'vendor_uuid'                    => 'vendor-uuid',
+        'current_job_uuid'               => 'order-uuid',
+        'user'                           => (object) ['public_id' => 'user_public'],
+        'company'                        => (object) ['public_id' => 'company_public', 'name' => 'Company One'],
+        'vehicle'                        => (object) ['public_id' => 'vehicle_public'],
+        'currentJob'                     => (object) ['public_id' => 'order_public'],
+        'vendor'                         => (object) ['public_id' => 'vendor_public'],
+        'name'                           => 'Jane Driver',
+        'email'                          => 'jane@example.test',
+        'phone'                          => '+15551112222',
+        'drivers_license_number'         => 'DL-77',
+        'license_expiry'                 => Carbon::parse('2027-05-10'),
+        'photo_url'                      => 'https://cdn.test/driver.png',
+        'avatar_url'                     => 'https://cdn.test/avatar.png',
+        'original'                       => ['avatar_url' => 'avatar-upload-token'],
+        'vehicle_name'                   => 'Truck 77',
+        'vehicle_avatar'                 => 'https://cdn.test/truck.png',
+        'vendor_name'                    => 'Vendor One',
+        'location'                       => ['type' => 'Point', 'coordinates' => [103.85, 1.29]],
+        'heading'                        => 90,
+        'altitude'                       => 12,
+        'speed'                          => 45,
+        'country'                        => 'SG',
+        'currency'                       => 'SGD',
+        'city'                           => 'Singapore',
+        'online'                         => true,
+        'status'                         => 'available',
+        'token'                          => 'driver-token',
+        'meta'                           => ['shift' => 'morning'],
+        'updated_at'                     => '2026-07-01 10:00:00',
+        'created_at'                     => '2026-01-01 09:00:00',
+    ], $overrides));
+}
+
+test('driver resource exposes internal identifiers counters and assignment metadata', function () {
+    $request = fleetopsDriverResourceRequest(true);
+    $payload = (new TestFleetOpsDriverResource(fleetopsDriverResourceFixture()))->resolve($request);
+
+    expect($payload)->toMatchArray([
+        'id'                      => 77,
+        'uuid'                    => 'driver-uuid',
+        'public_id'               => 'driver_public',
+        'user_uuid'               => 'user-uuid',
+        'company_uuid'            => 'company-uuid',
+        'vehicle_uuid'            => 'vehicle-uuid',
+        'vendor_uuid'             => 'vendor-uuid',
+        'current_job_uuid'        => 'order-uuid',
+        'avatar_value'            => 'avatar-upload-token',
+        'vehicle_name'            => 'Truck 77',
+        'vendor_name'             => 'Vendor One',
+        'assigned_orders_count'   => 4,
+        'current_order_reference' => 'order_current',
+        'drivers_license_number'  => 'DL-77',
+        'license_expiry'          => '2027-05-10',
+        'heading'                 => 90,
+        'altitude'                => 12,
+        'speed'                   => 45,
+        'online'                  => true,
+        'status'                  => 'available',
+        'meta'                    => ['shift' => 'morning'],
+    ]);
+});
+
+test('driver resource keeps public payload focused on public fields', function () {
+    $request = fleetopsDriverResourceRequest(false);
+    $payload = (new TestFleetOpsDriverResource(fleetopsDriverResourceFixture()))->resolve($request);
+
+    expect($payload['id'])->toBe('driver_public')
+        ->and($payload)->toMatchArray([
+            'internal_id'            => 'DRV-77',
+            'name'                   => 'Jane Driver',
+            'email'                  => 'jane@example.test',
+            'phone'                  => '+15551112222',
+            'drivers_license_number' => 'DL-77',
+            'license_expiry'         => '2027-05-10',
+            'photo_url'              => 'https://cdn.test/driver.png',
+            'avatar_url'             => 'https://cdn.test/avatar.png',
+            'vehicle_avatar'         => 'https://cdn.test/truck.png',
+            'country'                => 'SG',
+            'currency'               => 'SGD',
+            'city'                   => 'Singapore',
+            'online'                 => true,
+            'status'                 => 'available',
+        ]);
+});
+
+test('driver resource webhook payload serializes driver assignment details', function () {
+    $payload = (new TestFleetOpsDriverResource(fleetopsDriverResourceFixture()))->toWebhookPayload();
+
+    expect($payload)->toMatchArray([
+        'id'                     => 'driver_public',
+        'internal_id'            => 'DRV-77',
+        'name'                   => 'Jane Driver',
+        'email'                  => 'jane@example.test',
+        'phone'                  => '+15551112222',
+        'photo_url'              => 'https://cdn.test/driver.png',
+        'license_expiry'         => '2027-05-10',
+        'vehicle'                => 'vehicle_public',
+        'current_job'            => 'order_public',
+        'vendor'                 => 'vendor_public',
+        'heading'                => 90,
+        'altitude'               => 12,
+        'speed'                  => 45,
+        'country'                => 'SG',
+        'currency'               => 'SGD',
+        'city'                   => 'Singapore',
+        'online'                 => true,
+        'status'                 => 'available',
+        'meta'                   => ['shift' => 'morning'],
+    ]);
+});