@fleetbase/fleetops-engine 0.6.59 → 0.6.61

package/server/tests/Unit/Http/Resources/ManifestResourceTest.php

@@ -0,0 +1,129 @@
+<?php
+
+/*
+ * The models resolve their connection through a namespaced `config()`, which
+ * does not exist without the full application. Stubbed so a resource can be
+ * exercised on its own — the projection is the thing under test, not Eloquent.
+ */
+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 $default; }');
+}
+
+if (!function_exists('Fleetbase\FleetOps\Models\config')) {
+    eval('namespace Fleetbase\FleetOps\Models; function config($key = null, $default = null) { return $default; }');
+}
+
+use Fleetbase\FleetOps\Http\Resources\v1\Manifest as ManifestResource;
+use Fleetbase\FleetOps\Http\Resources\v1\ManifestStop as ManifestStopResource;
+use Fleetbase\FleetOps\Models\Manifest;
+use Fleetbase\FleetOps\Models\ManifestStop;
+use Illuminate\Http\Request;
+
+if (!class_exists('FleetOpsSupportRequestState')) {
+    class FleetOpsSupportRequestState
+    {
+        public static ?Request $request = null;
+    }
+}
+
+if (!function_exists('Fleetbase\Support\request')) {
+    eval('namespace Fleetbase\Support; function request($key = null, $default = null) { return \FleetOpsSupportRequestState::$request; }');
+}
+
+/**
+ * The manifest's stop counts are accessors that query the database, and the
+ * driver and vehicle names walk relations. None of that is what a resource test
+ * is for, so they are answered directly — the projection is under test, not
+ * Eloquent.
+ */
+class FleetOpsManifestFake extends Manifest
+{
+    public function getCompletedStopsAttribute(): int
+    {
+        return 3;
+    }
+
+    public function getPendingStopsAttribute(): int
+    {
+        return 5;
+    }
+
+    public function getDriverNameAttribute(): ?string
+    {
+        return 'Ron';
+    }
+
+    public function getVehicleNameAttribute(): ?string
+    {
+        return 'EAS-01';
+    }
+}
+
+test('manifest resource publishes what a driver needs to run a route', function () {
+    $request                             = Request::create('/v1/manifests/manifest_public', 'GET');
+    FleetOpsSupportRequestState::$request = $request;
+
+    $manifest = new FleetOpsManifestFake();
+    $manifest->setRawAttributes([
+        'id'               => 3,
+        'uuid'             => 'manifest-uuid',
+        'public_id'        => 'manifest_public',
+        'status'           => 'in_progress',
+        'total_distance_m' => 41200,
+        'total_duration_s' => 5400,
+        'stop_count'       => 8,
+        'notes'            => 'Cold chain first',
+    ], true);
+
+    $payload = (new ManifestResource($manifest))->resolve($request);
+
+    expect($payload['id'])->toBe('manifest_public')
+        ->and($payload['status'])->toBe('in_progress')
+        ->and($payload['total_distance_m'])->toBe(41200)
+        ->and($payload['stop_count'])->toBe(8)
+        ->and($payload['notes'])->toBe('Cold chain first')
+        ->and($payload['completed_stops'])->toBe(3)
+        ->and($payload['pending_stops'])->toBe(5)
+        ->and($payload['driver_name'])->toBe('Ron');
+});
+
+test('manifest resource omits stops when they were not loaded, so a list stays a list', function () {
+    // A driver's manifest list on a busy fleet must not drag every stop of
+    // every route along with it.
+    $request                             = Request::create('/v1/drivers/driver_public/manifests', 'GET');
+    FleetOpsSupportRequestState::$request = $request;
+
+    $manifest = new FleetOpsManifestFake();
+    $manifest->setRawAttributes(['id' => 4, 'uuid' => 'm-uuid', 'public_id' => 'manifest_public', 'status' => 'pending'], true);
+
+    $payload = (new ManifestResource($manifest))->resolve($request);
+
+    expect($payload)->not->toHaveKey('stops');
+});
+
+test('manifest stop resource carries the sequence a re-sequence rewrites', function () {
+    $request                             = Request::create('/v1/manifest-stops/stop_public', 'GET');
+    FleetOpsSupportRequestState::$request = $request;
+
+    $stop = new ManifestStop();
+    $stop->setRawAttributes([
+        'id'                   => 9,
+        'uuid'                 => 'stop-uuid',
+        'public_id'            => 'stop_public',
+        'status'               => 'pending',
+        'sequence'             => 4,
+        'distance_from_prev_m' => 1800,
+        'duration_from_prev_s' => 240,
+    ], true);
+
+    $payload = (new ManifestStopResource($stop))->resolve($request);
+
+    expect($payload['id'])->toBe('stop_public')
+        ->and($payload['sequence'])->toBe(4)
+        ->and($payload['status'])->toBe('pending')
+        ->and($payload['distance_from_prev_m'])->toBe(1800);
+});

package/server/tests/Unit/Http/Resources/OrderConfigResourceTest.php

@@ -45,3 +45,94 @@ test('order config resource projects empty and invalid flow as an empty list', f
     expect($payload['id'])->toBe('order_config_public')
         ->and($payload['flow'])->toBe([]);
 });
+
+test('order config resource publishes the flow graph so consumers can sequence it', function () {
+    $request                                          = Request::create('/v1/fleet-ops/order-configs/order_config_public', 'GET');
+    FleetOpsOrderConfigResourceRequestState::$request = $request;
+    FleetOpsSupportRequestState::$request             = $request;
+
+    // Declared deliberately out of workflow order, which is how flows are
+    // stored: `completed` before the step that leads to it, `dispatched` last.
+    $config = new OrderConfig();
+    $config->setRawAttributes([
+        'id'        => 8,
+        'uuid'      => 'order-config-uuid',
+        'public_id' => 'order_config_public',
+        'key'       => 'transport',
+        'name'      => 'Transport',
+        'flow'      => [
+            ['code' => 'completed', 'status' => 'Order Completed', 'complete' => true, 'activities' => []],
+            ['code' => 'created', 'status' => 'Order Created', 'activities' => ['dispatched']],
+            ['code' => 'dispatched', 'status' => 'Order Dispatched', 'activities' => ['enroute'], 'sequence' => 2],
+            [
+                'code'       => 'enroute',
+                'status'     => 'Driver Enroute',
+                'activities' => ['completed', 'failed'],
+                'logic'      => [['type' => 'and', 'conditions' => []]],
+            ],
+        ],
+    ], true);
+
+    $flow   = (new OrderConfigResource($config))->resolve($request)['flow'];
+    $byCode = collect($flow)->keyBy('code');
+
+    expect($byCode['created']['activities'])->toBe(['dispatched'])
+        ->and($byCode['dispatched']['sequence'])->toBe(2)
+        ->and($byCode['enroute']['activities'])->toBe(['completed', 'failed'])
+        ->and($byCode['enroute']['logic'])->toBe([['type' => 'and', 'conditions' => []]])
+        ->and($byCode['completed']['complete'])->toBeTrue();
+});
+
+test('order config resource normalises transitions written as objects', function () {
+    $request                                          = Request::create('/v1/fleet-ops/order-configs/order_config_public', 'GET');
+    FleetOpsOrderConfigResourceRequestState::$request = $request;
+    FleetOpsSupportRequestState::$request             = $request;
+
+    // Flows have been authored both ways; a consumer should not have to guess.
+    $config = new OrderConfig();
+    $config->setRawAttributes([
+        'id'        => 9,
+        'uuid'      => 'order-config-uuid',
+        'public_id' => 'order_config_public',
+        'key'       => 'transport',
+        'name'      => 'Transport',
+        'flow'      => [
+            ['code' => 'created', 'activities' => [['code' => 'dispatched'], 'enroute', ['label' => 'no code here']]],
+            // A flow hand-edited down to a single transition can leave a bare
+            // string where the list belongs. Publish an empty list rather than
+            // letting the shape vary — a consumer iterating the field should
+            // never have to type-check it.
+            ['code' => 'dispatched', 'activities' => 'enroute'],
+        ],
+    ], true);
+
+    $flow = (new OrderConfigResource($config))->resolve($request)['flow'];
+
+    expect($flow[0]['activities'])->toBe(['dispatched', 'enroute'])
+        ->and($flow[1]['activities'])->toBe([]);
+});
+
+test('order config resource keeps flow fields absent from a legacy activity null rather than missing', function () {
+    $request                                          = Request::create('/v1/fleet-ops/order-configs/order_config_public', 'GET');
+    FleetOpsOrderConfigResourceRequestState::$request = $request;
+    FleetOpsSupportRequestState::$request             = $request;
+
+    $config = new OrderConfig();
+    $config->setRawAttributes([
+        'id'        => 10,
+        'uuid'      => 'order-config-uuid',
+        'public_id' => 'order_config_public',
+        'key'       => 'transport',
+        'name'      => 'Transport',
+        'flow'      => [['code' => 'created', 'status' => 'Order Created']],
+    ], true);
+
+    $flow = (new OrderConfigResource($config))->resolve($request)['flow'];
+
+    // Present-and-null is a contract a client can read; absent is one it has to
+    // feel for.
+    expect($flow[0])->toHaveKeys(['sequence', 'activities', 'logic'])
+        ->and($flow[0]['sequence'])->toBeNull()
+        ->and($flow[0]['activities'])->toBe([])
+        ->and($flow[0]['logic'])->toBeNull();
+});

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

@@ -180,4 +180,11 @@ test('navigator driver onboard settings endpoint resolves company settings', fun
     $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([]);
+
+    // An unresolved public id is a client error. This drives the real
+    // errorResponse() seam, which the probe in SmallControllerContractsTest
+    // replaces — only the status is asserted, because the harness `response()`
+    // shim envelopes errors differently from the core-api macro it stands in for.
+    $missing = (new NavigatorController())->getDriverOnboardSettings('company_missing');
+    expect($missing->getStatusCode())->toBe(404);
 });

package/server/tests/Unit/Models/SensorLastPositionDefaultTest.php

@@ -0,0 +1,130 @@
+<?php
+
+use Fleetbase\FleetOps\Models\Sensor;
+use Fleetbase\LaravelMysqlSpatial\Types\Point as SpatialPoint;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Http\Request;
+use Illuminate\Support\Str;
+
+/**
+ * Covers Sensor::boot()'s creating hook, which defaults `last_position` to
+ * POINT(0,0).
+ *
+ * The same migration that made devices.last_position NOT NULL did it to sensors
+ * too, but only Device had a default. Creating a sensor through the API failed
+ * with "Field 'last_position' doesn't have a default value" — the Postman
+ * contract run caught it, having never been able to create a sensor at all.
+ *
+ * As with the device fixtures, the dispatcher is set up front so the model event
+ * actually fires; without it the hook is never registered and its body never runs.
+ */
+if (!function_exists('Fleetbase\Observers\event')) {
+    eval('namespace Fleetbase\Observers; function event($event = null, $payload = []) { return []; }');
+}
+
+if (!function_exists('Fleetbase\FleetOps\Observers\event')) {
+    eval('namespace Fleetbase\FleetOps\Observers; function event($event = null, $payload = []) { return []; }');
+}
+
+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\Models\session')) {
+    eval('namespace Fleetbase\Models; 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); } public function missing($k) { return \session($k) === null; } }; } return \session($key, $default); }');
+}
+
+if (!Str::hasMacro('humanize')) {
+    Str::macro('humanize', fn ($value) => ucfirst(str_replace(['_', '-'], ' ', Str::snake((string) $value))));
+}
+
+function fleetopsSensorDefaultBoot(): SQLiteConnection
+{
+    $pdo = new PDO('sqlite::memory:');
+    $pdo->sqliteCreateFunction('ST_PointFromText', fn ($wkt, $srid = 0, $axisOrder = null) => $wkt);
+    $pdo->sqliteCreateFunction('ST_GeomFromText', fn ($wkt, $srid = 0, $axisOrder = null) => $wkt);
+    $connection = new SQLiteConnection($pdo);
+    $resolver   = new ConnectionResolver(['default' => $connection, 'mysql' => $connection]);
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+
+    // The creating hook is registered against whichever dispatcher is present
+    // when the model boots, so it has to exist before Device is ever touched.
+    if (!EloquentModel::getEventDispatcher()) {
+        EloquentModel::setEventDispatcher(new Illuminate\Events\Dispatcher());
+    }
+
+    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);
+        }
+    });
+    app()->instance('db.schema', $connection->getSchemaBuilder());
+    app()->instance('responsecache', new class {
+        public function __call($method, $arguments)
+        {
+            return null;
+        }
+    });
+    Illuminate\Support\Facades\DB::clearResolvedInstance('db');
+    app()->instance('request', Request::create('/v1/sensors'));
+
+    config()->set('activitylog.enabled', false);
+    config()->set('activitylog.default_auth_driver', 'web');
+    app()->bind(Illuminate\Contracts\Config\Repository::class, fn () => config());
+
+    $schema = $connection->getSchemaBuilder();
+    $schema->create('sensors', function ($blueprint) {
+        $blueprint->increments('id');
+        foreach (['uuid', 'public_id', 'internal_id', 'company_uuid', 'telematic_uuid', 'device_uuid', 'name', 'slug', 'type', 'status', 'online', 'unit', 'last_value', 'last_reading_at', 'min_threshold', 'max_threshold', 'location', 'last_position', 'meta', 'data', 'options', 'notes', '_key'] as $column) {
+            $blueprint->string($column)->nullable();
+        }
+        $blueprint->timestamps();
+        $blueprint->timestamp('deleted_at')->nullable();
+    });
+
+    session(['company' => 'company-1']);
+
+    return $connection;
+}
+
+test('creating a sensor without a position defaults it to the null island', function () {
+    fleetopsSensorDefaultBoot();
+
+    $sensor = Sensor::create([
+        'company_uuid' => 'company-1',
+        'name'         => 'Defaulted Sensor',
+        'type'         => 'temperature',
+    ]);
+
+    expect($sensor->last_position)->toBeInstanceOf(SpatialPoint::class)
+        ->and($sensor->last_position->getLat())->toBe(0.0)
+        ->and($sensor->last_position->getLng())->toBe(0.0);
+});
+
+test('creating a sensor with a position leaves it untouched', function () {
+    fleetopsSensorDefaultBoot();
+
+    $sensor = Sensor::create([
+        'company_uuid'  => 'company-1',
+        'name'          => 'Positioned Sensor',
+        'type'          => 'temperature',
+        'last_position' => new SpatialPoint(1.3, 103.8),
+    ]);
+
+    expect($sensor->last_position)->toBeInstanceOf(SpatialPoint::class)
+        ->and($sensor->last_position->getLat())->toBe(1.3)
+        ->and($sensor->last_position->getLng())->toBe(103.8);
+});

package/translations/en-us.yaml

@@ -2006,6 +2006,10 @@ settings:
         map-provider: Map Provider
         map-provider-help-text: Choose the map engine used to render the live operations map. Leaflet uses OpenStreetMap tiles and requires no API key. Google Maps requires a valid Google Maps JavaScript API key.
         select-map-provider: Select map provider
+        leaflet-tile-url: Leaflet Tile Provider URL
+        leaflet-tile-url-help-text: Optional custom XYZ tile provider URL template used by the Leaflet map. Leave blank to use the default OpenStreetMap tiles which require no API key. Use this to point Leaflet at your own tile provider, including keyed providers such as CARTO.
+        leaflet-dark-tile-url: Leaflet Dark Mode Tile Provider URL
+        leaflet-dark-tile-url-help-text: Optional tile provider URL used when the console is in dark mode. Leave blank to fall back to the tile provider URL above, or the default OpenStreetMap tiles.
         google-maps-map-type: Map Type
         google-maps-map-type-help-text: The default map style to display when Google Maps is active.
         select-map-type: Select map type