@fleetbase/fleetops-engine 0.6.58 → 0.6.60

package/server/tests/Unit/Support/Ai/Capabilities/SearchResourcesCapabilityTest.php

@@ -0,0 +1,237 @@
+<?php
+
+use Fleetbase\Ai\Models\AiTask;
+use Fleetbase\FleetOps\Models\Device;
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\Maintenance;
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Models\Sensor;
+use Fleetbase\FleetOps\Models\Telematic;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Models\WorkOrder;
+use Fleetbase\FleetOps\Support\Ai\Capabilities\SearchResourcesCapability;
+
+class FleetOpsSearchResourcesQueryFake
+{
+    public array $calls = [];
+
+    public function __construct(public array $records = [])
+    {
+    }
+
+    public function where(...$arguments): self
+    {
+        $this->calls[] = ['where', $arguments];
+
+        if (isset($arguments[0]) && is_callable($arguments[0])) {
+            $arguments[0]($this);
+        }
+
+        return $this;
+    }
+
+    public function orWhere(...$arguments): self
+    {
+        $this->calls[] = ['orWhere', $arguments];
+
+        return $this;
+    }
+
+    public function orWhereHas(string $relation, Closure $callback): self
+    {
+        $related = new self();
+        $callback($related);
+        $this->calls[] = ['orWhereHas', $relation, $related->calls];
+
+        return $this;
+    }
+
+    public function limit(int $limit): self
+    {
+        $this->calls[] = ['limit', $limit];
+
+        return $this;
+    }
+
+    public function get()
+    {
+        $this->calls[] = ['get'];
+
+        return collect($this->records);
+    }
+}
+
+class FleetOpsSearchResourcesCapabilityProbe extends SearchResourcesCapability
+{
+    public array $allowedPermissions = [];
+    public array $queries            = [];
+    public array $appliedLikes       = [];
+
+    public function exposePromptMatches(string $prompt): bool
+    {
+        return $this->matchesPrompt($prompt);
+    }
+
+    protected function can(string $permission): bool
+    {
+        return in_array($permission, $this->allowedPermissions, true);
+    }
+
+    protected function whereLikeAny($builder, array $columns, array $terms): void
+    {
+        $this->appliedLikes[] = [$columns, $terms];
+
+        if ($builder instanceof FleetOpsSearchResourcesQueryFake) {
+            $builder->calls[] = ['whereLikeAny', $columns, $terms];
+        }
+    }
+
+    protected function orderSearchQuery()
+    {
+        return $this->queries['orders'];
+    }
+
+    protected function vehicleSearchQuery()
+    {
+        return $this->queries['vehicles'];
+    }
+
+    protected function driverSearchQuery()
+    {
+        return $this->queries['drivers'];
+    }
+
+    protected function genericSearchQuery(string $modelClass)
+    {
+        return match ($modelClass) {
+            WorkOrder::class   => $this->queries['work_orders'],
+            Maintenance::class => $this->queries['maintenances'],
+            Device::class      => $this->queries['devices'],
+            Sensor::class      => $this->queries['sensors'],
+            Telematic::class   => $this->queries['telematics'],
+        };
+    }
+}
+
+function fleetopsSearchResourcesModel(string $class, array $attributes)
+{
+    $model = new $class();
+    $model->setRawAttributes($attributes, true);
+
+    return $model;
+}
+
+test('search resources resolve returns authorized resource summaries across all supported branches', function () {
+    $order = fleetopsSearchResourcesModel(Order::class, [
+        'public_id' => 'order_public',
+        'uuid'      => 'order-uuid',
+        'status'    => 'dispatched',
+        'type'      => 'transport',
+    ]);
+    $order->setRelation('trackingNumber', (object) ['tracking_number' => 'TRK-1']);
+    $order->setRelation('transaction', (object) ['amount' => 125.5, 'currency' => 'SGD']);
+
+    $vehicle = fleetopsSearchResourcesModel(Vehicle::class, [
+        'public_id'    => 'vehicle_public',
+        'uuid'         => 'vehicle-uuid',
+        'name'         => 'Van 12',
+        'plate_number' => 'SBA1234Z',
+        'status'       => 'active',
+    ]);
+
+    $driver = fleetopsSearchResourcesModel(Driver::class, [
+        'public_id' => 'driver_public',
+        'uuid'      => 'driver-uuid',
+        'status'    => 'available',
+    ]);
+    $driver->setRelation('user', (object) ['name' => 'Ada Driver']);
+
+    $workOrder = fleetopsSearchResourcesModel(WorkOrder::class, [
+        'public_id' => 'work_order_public',
+        'uuid'      => 'work-order-uuid',
+        'name'      => 'Inspect liftgate',
+        'status'    => 'open',
+    ]);
+
+    $maintenance = fleetopsSearchResourcesModel(Maintenance::class, [
+        'public_id' => 'maintenance_public',
+        'uuid'      => 'maintenance-uuid',
+        'name'      => 'Quarterly service',
+        'status'    => 'scheduled',
+    ]);
+
+    $device = fleetopsSearchResourcesModel(Device::class, [
+        'public_id' => 'device_public',
+        'uuid'      => 'device-uuid',
+        'name'      => 'Tablet 7',
+        'status'    => 'online',
+    ]);
+
+    $sensor = fleetopsSearchResourcesModel(Sensor::class, [
+        'public_id' => 'sensor_public',
+        'uuid'      => 'sensor-uuid',
+        'name'      => 'Temperature probe',
+        'status'    => 'active',
+    ]);
+
+    $telematic = fleetopsSearchResourcesModel(Telematic::class, [
+        'public_id' => 'telematic_public',
+        'uuid'      => 'telematic-uuid',
+        'name'      => 'Flespi Gateway',
+        'status'    => 'connected',
+    ]);
+
+    $capability                     = new FleetOpsSearchResourcesCapabilityProbe();
+    $capability->allowedPermissions = $capability->permissions();
+    $capability->queries            = [
+        'orders'       => new FleetOpsSearchResourcesQueryFake([$order]),
+        'vehicles'     => new FleetOpsSearchResourcesQueryFake([$vehicle]),
+        'drivers'      => new FleetOpsSearchResourcesQueryFake([$driver]),
+        'work_orders'  => new FleetOpsSearchResourcesQueryFake([$workOrder]),
+        'maintenances' => new FleetOpsSearchResourcesQueryFake([$maintenance]),
+        'devices'      => new FleetOpsSearchResourcesQueryFake([$device]),
+        'sensors'      => new FleetOpsSearchResourcesQueryFake([$sensor]),
+        'telematics'   => new FleetOpsSearchResourcesQueryFake([$telematic]),
+    ];
+
+    $result = $capability->resolve(new AiTask(['prompt' => 'Find order ORDER-1 vehicle VEH-1 driver DRV-1 device DEV-1 sensor SNS-1 telematic TEL-1']));
+
+    expect($capability->exposePromptMatches('look up work order WO-1'))->toBeTrue()
+        ->and($result['query_terms'])->toBe(['ORDER-1', 'VEH-1', 'DRV-1', 'device', 'DEV-1', 'sensor'])
+        ->and($result['results'])->toHaveKeys(['orders', 'vehicles', 'drivers', 'work_orders', 'maintenances', 'devices', 'sensors', 'telematics'])
+        ->and($result['results']['orders'][0])->toMatchArray([
+            'id'                   => 'order_public',
+            'uuid'                 => 'order-uuid',
+            'tracking'             => 'TRK-1',
+            'status'               => 'dispatched',
+            'type'                 => 'transport',
+            'transaction_amount'   => 125.5,
+            'transaction_currency' => 'SGD',
+            'route'                => 'console.fleet-ops.operations.orders.index.details',
+            'models'               => ['order_public'],
+        ])
+        ->and($result['results']['vehicles'][0])->toMatchArray([
+            'id'     => 'vehicle_public',
+            'uuid'   => 'vehicle-uuid',
+            'name'   => 'Van 12',
+            'plate'  => 'SBA1234Z',
+            'status' => 'active',
+            'route'  => 'console.fleet-ops.management.vehicles.index.details',
+            'models' => ['vehicle_public'],
+        ])
+        ->and($result['results']['drivers'][0])->toMatchArray([
+            'id'     => 'driver_public',
+            'uuid'   => 'driver-uuid',
+            'name'   => 'Ada Driver',
+            'status' => 'available',
+            'route'  => 'console.fleet-ops.management.drivers.index.details',
+            'models' => ['driver_public'],
+        ])
+        ->and($result['results']['work_orders'][0]['name'])->toBe('Inspect liftgate')
+        ->and($result['results']['maintenances'][0]['name'])->toBe('Quarterly service')
+        ->and($result['results']['devices'][0]['route'])->toBe('console.fleet-ops.connectivity.devices.index.details')
+        ->and($result['results']['sensors'][0]['route'])->toBe('console.fleet-ops.connectivity.sensors.index.details')
+        ->and($result['results']['telematics'][0]['route'])->toBe('console.fleet-ops.connectivity.telematics.details')
+        ->and($capability->queries['orders']->calls)->toContain(['limit', 5], ['get'])
+        ->and($capability->appliedLikes)->not->toBeEmpty();
+});

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

@@ -0,0 +1,124 @@
+<?php
+
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Support\Ai\Capabilities\OperationalQueryCapability;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+/**
+ * Covers the AbstractFleetOpsAICapability shared helpers through the
+ * concrete OperationalQueryCapability: permission checks with the admin
+ * session bypass, the all-permissions conjunction, search-term extraction
+ * with stop-word filtering, and the multi-column like matcher.
+ */
+if (!function_exists('Fleetbase\Support\session')) {
+    eval('namespace Fleetbase\Support; function session($key = null, $default = null) { if ($key === null) { return new class { public function has($k) { return \session($k) !== null; } public function get($k, $d = null) { return \session($k, $d); } }; } return \session($key, $default); }');
+}
+
+if (!function_exists('Fleetbase\Support\auth')) {
+    eval('namespace Fleetbase\Support; function auth() { return new class { public function user() { return null; } public function id() { return null; } }; }');
+}
+
+function fleetopsAiPermissionsBoot(): 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 = [
+        'users'    => ['uuid', 'public_id', 'company_uuid', 'name', 'type', 'status'],
+        'vehicles' => ['uuid', 'public_id', 'company_uuid', 'name', 'plate_number'],
+    ];
+    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']);
+
+    return $connection;
+}
+
+function fleetopsAiPermissionsHelper(string $method): ReflectionMethod
+{
+    $reflection = new ReflectionMethod(OperationalQueryCapability::class, $method);
+    $reflection->setAccessible(true);
+
+    return $reflection;
+}
+
+test('permission checks pass for admin session users', function () {
+    $connection = fleetopsAiPermissionsBoot();
+    $connection->table('users')->insert(['uuid' => 'admin-1', 'company_uuid' => 'company-1', 'type' => 'admin']);
+    session(['user' => 'admin-1']);
+
+    $capability = new OperationalQueryCapability();
+
+    expect(fleetopsAiPermissionsHelper('can')->invoke($capability, 'fleet-ops list order'))->toBeTrue()
+        ->and(fleetopsAiPermissionsHelper('canAll')->invoke($capability, ['fleet-ops list order', 'fleet-ops list driver']))->toBeTrue();
+});
+
+test('permission checks for non admin users delegate to the gate', function () {
+    fleetopsAiPermissionsBoot();
+    session(['user' => null]);
+
+    $capability = new OperationalQueryCapability();
+
+    // Without an admin session user the check falls through to Auth::can,
+    // whose permission guard is unavailable in the harness — the delegation
+    // line still executes, which is the covered contract here.
+    expect(fn () => fleetopsAiPermissionsHelper('can')->invoke($capability, 'fleet-ops list order'))->toThrow(TypeError::class)
+        ->and(fn () => fleetopsAiPermissionsHelper('canAll')->invoke($capability, ['fleet-ops list order']))->toThrow(TypeError::class);
+});
+
+test('search terms extract identifiers and fall back to the raw prompt', function () {
+    fleetopsAiPermissionsBoot();
+    $capability  = new OperationalQueryCapability();
+    $searchTerms = fleetopsAiPermissionsHelper('searchTerms');
+
+    $terms = $searchTerms->invoke($capability, 'find order TRK-12345 for vehicle atlas99');
+    expect($terms)->toContain('TRK-12345', 'atlas99')
+        ->and($terms)->not->toContain('find', 'order');
+
+    // Stop-word-only prompts fall back to the trimmed prompt
+    expect($searchTerms->invoke($capability, 'find order'))->toBe(['find order']);
+});
+
+test('where like any matches across columns and terms', function () {
+    $connection = fleetopsAiPermissionsBoot();
+    $connection->table('vehicles')->insert([
+        ['uuid' => 'vehicle-1', 'company_uuid' => 'company-1', 'name' => 'Atlas Truck', 'plate_number' => 'AAA-1'],
+        ['uuid' => 'vehicle-2', 'company_uuid' => 'company-1', 'name' => 'Other', 'plate_number' => 'ZED-9'],
+    ]);
+
+    $capability = new OperationalQueryCapability();
+    $builder    = Vehicle::query();
+    fleetopsAiPermissionsHelper('whereLikeAny')->invoke($capability, $builder, ['name', 'plate_number'], ['Atlas', 'ZED']);
+
+    expect($builder->get())->toHaveCount(2);
+});

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

@@ -0,0 +1,24 @@
+<?php
+
+use Fleetbase\FleetOps\Support\Algo;
+
+/**
+ * Covers the Algo expression evaluator edge branches: unrounded results,
+ * min/ceil/floor/round helper functions, and non-numeric helper arguments
+ * falling back to float casts.
+ */
+test('algo evaluates unrounded expressions and helper function arms', function () {
+    // Unrounded evaluation returns the raw numeric result
+    expect((float) Algo::exec('3.14159 * 2', [], false))->toBeGreaterThan(6.28)
+        ->and(Algo::exec('1 + 1', [], true))->toBe(2.0);
+
+    // Helper functions cover the min/ceil/floor/round arms
+    expect(Algo::exec('min(4, 9)', [], true))->toBe(4.0)
+        ->and(Algo::exec('max(4, 9)', [], true))->toBe(9.0)
+        ->and(Algo::exec('ceil(4.2)', [], true))->toBe(5.0)
+        ->and(Algo::exec('floor(4.8)', [], true))->toBe(4.0)
+        ->and(Algo::exec('round(4.567, 2)', [], true))->toBe(4.57);
+
+    // Non-evaluable helper arguments fall back to float casts
+    expect(Algo::exec('max(oops, 3)', [], true))->toBe(3.0);
+});

package/server/tests/Unit/Support/Analytics/GeofenceViolationsTest.php

@@ -0,0 +1,109 @@
+<?php
+
+if (!function_exists('Fleetbase\Traits\config')) {
+    eval('namespace Fleetbase\Traits; function config($key = null, $default = null) { return $key === "api.cache.enabled" ? false : $default; }');
+}
+
+use Fleetbase\FleetOps\Support\Analytics\GeofenceViolations;
+use Fleetbase\Models\Company;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Support\Carbon;
+
+function fleetopsGeofenceViolationsUseInMemoryConnection(): SQLiteConnection
+{
+    $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
+    $connection->statement('create table geofence_events_log (uuid varchar(64), 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)');
+
+    $resolver = new ConnectionResolver([
+        'default' => $connection,
+        'mysql'   => $connection,
+    ]);
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+
+    return $connection;
+}
+
+function fleetopsGeofenceViolationsCompany(): Company
+{
+    $company = new Company();
+    $company->setRawAttributes(['uuid' => 'company-geofence-violations'], true);
+
+    return $company;
+}
+
+test('geofence violations summarizes today period dwell outliers and zone totals', function () {
+    Carbon::setTestNow('2026-07-26 10:00:00');
+
+    $connection = fleetopsGeofenceViolationsUseInMemoryConnection();
+    $connection->table('geofence_events_log')->insert([
+        [
+            'uuid'                   => 'today-dwell-high',
+            'company_uuid'           => 'company-geofence-violations',
+            'driver_uuid'            => 'driver-1',
+            'subject_name'           => 'Driver One',
+            'geofence_uuid'          => 'zone-1',
+            'geofence_type'          => 'zone',
+            'geofence_name'          => 'Warehouse',
+            'event_type'             => 'dwelled',
+            'dwell_duration_minutes' => 47,
+            'occurred_at'            => '2026-07-26 08:30:00',
+        ],
+        [
+            'uuid'                   => 'today-dwell-low',
+            'company_uuid'           => 'company-geofence-violations',
+            'driver_uuid'            => 'driver-2',
+            'subject_name'           => 'Driver Two',
+            'geofence_uuid'          => 'zone-1',
+            'geofence_type'          => 'zone',
+            'geofence_name'          => 'Warehouse',
+            'event_type'             => 'dwelled',
+            'dwell_duration_minutes' => 12,
+            'occurred_at'            => '2026-07-26 09:00:00',
+        ],
+        [
+            'uuid'                   => 'period-unnamed',
+            'company_uuid'           => 'company-geofence-violations',
+            'driver_uuid'            => 'driver-3',
+            'subject_name'           => 'Driver Three',
+            'geofence_uuid'          => 'zone-2',
+            'geofence_type'          => 'zone',
+            'geofence_name'          => null,
+            'event_type'             => 'entered',
+            'dwell_duration_minutes' => null,
+            'occurred_at'            => '2026-07-25 09:00:00',
+        ],
+        [
+            'uuid'                   => 'outside-company',
+            'company_uuid'           => 'company-other',
+            'driver_uuid'            => 'driver-4',
+            'subject_name'           => 'Driver Four',
+            'geofence_uuid'          => 'zone-3',
+            'geofence_type'          => 'zone',
+            'geofence_name'          => 'Other Zone',
+            'event_type'             => 'dwelled',
+            'dwell_duration_minutes' => 99,
+            'occurred_at'            => '2026-07-26 09:30:00',
+        ],
+    ]);
+
+    $summary = GeofenceViolations::forCompany(fleetopsGeofenceViolationsCompany())
+        ->between(Carbon::parse('2026-07-24'), Carbon::parse('2026-07-27'))
+        ->get();
+
+    expect($summary['violations_today'])->toBe(2)
+        ->and($summary['violations_period'])->toBe(2)
+        ->and($summary['top_dwells'])->toHaveCount(2)
+        ->and($summary['top_dwells'][0])->toMatchArray([
+            'driver_uuid'      => 'driver-1',
+            'driver_name'      => 'Driver One',
+            'zone_name'        => 'Warehouse',
+            'duration_minutes' => 47,
+        ])
+        ->and($summary['by_zone']['labels'])->toBe(['Warehouse', 'Unnamed'])
+        ->and($summary['by_zone']['data'])->toBe([2, 1]);
+
+    Carbon::setTestNow();
+});