@fleetbase/fleetops-engine 0.6.58 → 0.6.59

package/server/tests/Feature/Http/Api/ZoneControllerBordersAndSeamsTest.php

@@ -0,0 +1,294 @@
+<?php
+
+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; } }; }');
+}
+
+if (!function_exists('Fleetbase\Observers\event')) {
+    eval('namespace Fleetbase\Observers; function event($event = null, $payload = []) { return []; }');
+}
+
+use Fleetbase\FleetOps\Http\Controllers\Api\v1\ZoneController;
+use Fleetbase\FleetOps\Http\Requests\CreateZoneRequest;
+use Fleetbase\FleetOps\Http\Requests\UpdateZoneRequest;
+use Fleetbase\FleetOps\Models\Zone;
+use Fleetbase\LaravelMysqlSpatial\Types\Point;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+/**
+ * Covers the API ZoneController against SQLite: creating zones with borders
+ * derived from latitude/longitude pairs and location inputs with service
+ * area assignment, updating zone borders, and the protected helper seams
+ * for radius parsing, border construction, record persistence, lookups,
+ * resources and responses.
+ */
+class FleetOpsZoneControllerProbe extends ZoneController
+{
+    public function callHelper(string $method, ...$arguments): mixed
+    {
+        return $this->{$method}(...$arguments);
+    }
+}
+
+function fleetopsZoneWkbFromWkt(string $wkt): ?string
+{
+    $wkt        = trim($wkt);
+    $packPoints = function (string $body): string {
+        $points = array_map('trim', explode(',', $body));
+        $out    = pack('V', count($points));
+        foreach ($points as $pair) {
+            [$lng, $lat] = array_map('floatval', preg_split('/\s+/', trim($pair)));
+            $out .= pack('d', $lng) . pack('d', $lat);
+        }
+
+        return $out;
+    };
+
+    if (preg_match('/^POINT\(([^)]+)\)$/i', $wkt, $m)) {
+        [$lng, $lat] = array_map('floatval', preg_split('/\s+/', trim($m[1])));
+
+        return pack('V', 0) . pack('C', 1) . pack('V', 1) . pack('d', $lng) . pack('d', $lat);
+    }
+
+    if (preg_match('/^POLYGON\((.+)\)$/is', $wkt, $m)) {
+        preg_match_all('/\(([^()]+)\)/', $m[1], $rings);
+        $body = pack('C', 1) . pack('V', 3) . pack('V', count($rings[1]));
+        foreach ($rings[1] as $ring) {
+            $body .= $packPoints($ring);
+        }
+
+        return pack('V', 0) . $body;
+    }
+
+    if (preg_match('/^MULTIPOLYGON\((.+)\)$/is', $wkt, $m)) {
+        preg_match_all('/\(\(([^()]+(?:\),\([^()]+)*)\)\)/', $m[1], $polygons);
+        $body = pack('C', 1) . pack('V', 6) . pack('V', count($polygons[1]));
+        foreach ($polygons[1] as $polygon) {
+            $rings = preg_split('/\),\(/', $polygon);
+            $body .= pack('C', 1) . pack('V', 3) . pack('V', count($rings));
+            foreach ($rings as $ring) {
+                $body .= $packPoints($ring);
+            }
+        }
+
+        return pack('V', 0) . $body;
+    }
+
+    return null;
+}
+
+function fleetopsZoneBoot(): SQLiteConnection
+{
+    if (!Illuminate\Support\Str::hasMacro('humanize')) {
+        Illuminate\Support\Str::macro('humanize', fn ($value, $uppercase = true) => str_replace('_', ' ', Illuminate\Support\Str::snake((string) $value)));
+    }
+
+    $pdo = new PDO('sqlite::memory:');
+    $pdo->sqliteCreateFunction('ST_PointFromText', fn ($wkt, $srid = 0, $axisOrder = null) => fleetopsZoneWkbFromWkt((string) $wkt) ?? $wkt);
+    $pdo->sqliteCreateFunction('ST_GeomFromText', fn ($wkt, $srid = 0, $axisOrder = null) => fleetopsZoneWkbFromWkt((string) $wkt) ?? $wkt);
+    $connection = new class($pdo) extends SQLiteConnection {
+        public function prepareBindings(array $bindings)
+        {
+            // The sqlite grammar binds spatial objects as strings, so convert
+            // geometries to parseable spatial WKB at bind time
+            foreach ($bindings as $key => $value) {
+                if ($value instanceof Fleetbase\LaravelMysqlSpatial\Types\Geometry) {
+                    $bindings[$key] = fleetopsZoneWkbFromWkt($value->toWKT()) ?? (string) $value;
+                }
+            }
+
+            return parent::prepareBindings($bindings);
+        }
+    };
+    $resolver   = new ConnectionResolver(['default' => $connection, 'mysql' => $connection]);
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+    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());
+    Illuminate\Support\Facades\DB::clearResolvedInstance('db');
+
+    app()->instance('responsecache', new class {
+        public function __call($method, $arguments)
+        {
+            return null;
+        }
+    });
+    config()->set('activitylog.enabled', false);
+    config()->set('activitylog.default_auth_driver', 'web');
+    app()->bind(Illuminate\Contracts\Config\Repository::class, fn () => config());
+
+    $schema = $connection->getSchemaBuilder();
+    $tables = [
+        'zones'         => ['uuid', 'public_id', 'company_uuid', 'service_area_uuid', 'name', 'description', 'border', 'color', 'stroke_color', 'status', '_key'],
+        'service_areas' => ['uuid', 'public_id', 'company_uuid', 'name', 'type', 'status', 'border', '_key'],
+    ];
+    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']);
+
+    // The webhook lifecycle observer serializes zone locations through the
+    // unavailable GEOS engine — detach post-persistence listeners while
+    // keeping the creating-hooks that generate uuids
+    new Zone();
+    $dispatcher = EloquentModel::getEventDispatcher();
+    foreach (['created', 'updated', 'deleted', 'restored'] as $event) {
+        $dispatcher->forget('eloquent.' . $event . ': ' . Zone::class);
+    }
+
+    return $connection;
+}
+
+test('creating zones derives borders from coordinates and locations', function () {
+    $connection = fleetopsZoneBoot();
+    $connection->table('service_areas')->insert(['uuid' => '11111111-1111-4111-8111-111111111111', 'public_id' => 'sa_zoneparent1', 'company_uuid' => 'company-1', 'name' => 'Parent Area']);
+    $controller = new ZoneController();
+
+    $fromCoords = $controller->create(CreateZoneRequest::create('/v1/zones', 'POST', [
+        'name'         => 'Coord Zone',
+        'latitude'     => 1.30,
+        'longitude'    => 103.80,
+        'radius'       => 250,
+        'service_area' => 'sa_zoneparent1',
+    ]));
+    expect($connection->table('zones')->where('name', 'Coord Zone')->count())->toBe(1)
+        ->and($connection->table('zones')->where('name', 'Coord Zone')->value('service_area_uuid'))->toBe('11111111-1111-4111-8111-111111111111')
+        ->and($connection->table('zones')->where('name', 'Coord Zone')->value('border'))->not->toBeNull();
+
+    $fromLocation = $controller->create(CreateZoneRequest::create('/v1/zones', 'POST', [
+        'name'     => 'Location Zone',
+        'location' => ['lat' => 1.35, 'lng' => 103.85],
+    ]));
+    expect($connection->table('zones')->where('name', 'Location Zone')->count())->toBe(1)
+        ->and($connection->table('zones')->where('name', 'Location Zone')->value('border'))->not->toBeNull();
+});
+
+test('updating zones rebuilds borders and missing ids respond not found', function () {
+    $connection = fleetopsZoneBoot();
+    $connection->table('zones')->insert(['uuid' => '22222222-2222-4222-8222-222222222222', 'public_id' => 'zone_updone1', 'company_uuid' => 'company-1', 'name' => 'Zone One']);
+
+    $controller = new ZoneController();
+
+    $updated = $controller->update('zone_updone1', UpdateZoneRequest::create('/v1/zones/zone_updone1', 'PUT', [
+        'name'      => 'Zone One Updated',
+        'latitude'  => 1.31,
+        'longitude' => 103.81,
+        'radius'    => 300,
+    ]));
+    expect($connection->table('zones')->value('name'))->toBe('Zone One Updated')
+        ->and($connection->table('zones')->value('border'))->not->toBeNull();
+
+    $missing = $controller->update('zone_missing', UpdateZoneRequest::create('/v1/zones/zone_missing', 'PUT', ['name' => 'X']));
+    expect($missing->getStatusCode())->toBe(404);
+});
+
+test('updating a zone border round trips the polygon through the cast', function () {
+    $connection = fleetopsZoneBoot();
+    $connection->table('zones')->insert([
+        'uuid'         => '22222222-2222-4222-8222-222222222299',
+        'public_id'    => 'zone_roundtrip1',
+        'company_uuid' => 'company-1',
+        'name'         => 'Round Trip Zone',
+        'border'       => fleetopsZoneWkbFromWkt('POLYGON((103.8 1.3,103.9 1.3,103.9 1.4,103.8 1.3))'),
+    ]);
+
+    // Updates do not pass through SpatialTrait::performInsert, so whatever the
+    // Polygon cast returns is bound directly. Rewrite the border and read the
+    // vertices back to prove the geometry survives that path intact.
+    $zone         = Zone::where('public_id', 'zone_roundtrip1')->first();
+    $zone->border = new Fleetbase\LaravelMysqlSpatial\Types\Polygon([
+        new Fleetbase\LaravelMysqlSpatial\Types\LineString([
+            new Point(1.35, 103.85),
+            new Point(1.35, 103.95),
+            new Point(1.45, 103.95),
+            new Point(1.35, 103.85),
+        ]),
+    ]);
+    $zone->save();
+
+    $reloaded = Zone::where('public_id', 'zone_roundtrip1')->first();
+    $border   = $reloaded->border;
+
+    expect($border)->toBeInstanceOf(Fleetbase\LaravelMysqlSpatial\Types\Polygon::class);
+
+    $vertices = collect($border->getLineStrings()[0]->getPoints())
+        ->map(fn ($point) => [round($point->getLat(), 6), round($point->getLng(), 6)])
+        ->all();
+
+    expect($vertices)->toBe([
+        [1.35, 103.85],
+        [1.35, 103.95],
+        [1.45, 103.95],
+        [1.35, 103.85],
+    ]);
+});
+
+test('helper seams parse radii build borders and wrap resources', function () {
+    $connection = fleetopsZoneBoot();
+    $connection->table('zones')->insert(['uuid' => '22222222-2222-4222-8222-222222222222', 'public_id' => 'zone_seams1', 'company_uuid' => 'company-1', 'name' => 'Seam Zone']);
+    $probe = new FleetOpsZoneControllerProbe();
+
+    expect($probe->callHelper('radiusFromRequest', Illuminate\Http\Request::create('/x', 'GET', ['radius' => '750'])))->toBe(750)
+        ->and($probe->callHelper('radiusFromRequest', Illuminate\Http\Request::create('/x', 'GET')))->toBe(500)
+        ->and($probe->callHelper('createBorderFromPoint', new Point(1.30, 103.80), 300))->not->toBeNull()
+        ->and($probe->callHelper('pointFromLocation', ['lat' => 1.31, 'lng' => 103.81]))->toBeInstanceOf(Point::class)
+        ->and($probe->callHelper('findZoneRecord', 'zone_seams1')?->uuid)->toBe('22222222-2222-4222-8222-222222222222');
+
+    $created = $probe->callHelper('createZone', ['company_uuid' => 'company-1', 'name' => 'Seam Created']);
+    expect($created)->toBeInstanceOf(Zone::class);
+
+    expect($probe->callHelper('zoneResource', $created))->not->toBeNull()
+        ->and($probe->callHelper('zoneResourceCollection', collect([$created])))->not->toBeNull()
+        ->and($probe->callHelper('deletedZoneResource', $created))->not->toBeNull()
+        ->and($probe->callHelper('jsonResponse', ['ok' => true], 200)->getData(true))->toBe(['ok' => true]);
+});
+
+test('zone centroids and location accessors resolve through injected engines', function () {
+    $connection = fleetopsZoneBoot();
+    Brick\Geo\Engine\GeometryEngineRegistry::set(new class(new PDO('sqlite::memory:'), false) extends Brick\Geo\Engine\PDOEngine {
+        public function centroid(Brick\Geo\Geometry $g): Brick\Geo\Point
+        {
+            return Brick\Geo\Point::xy(1.32, 103.82);
+        }
+    });
+
+    $connection->table('zones')->insert(['uuid' => '33333333-3333-4333-8333-333333333333', 'public_id' => 'zone_centroid1', 'company_uuid' => 'company-1', 'name' => 'Centroid Zone', 'border' => fleetopsZoneWkbFromWkt('POLYGON((103.8 1.3,103.9 1.3,103.9 1.4,103.8 1.3))')]);
+    $zone = Zone::where('uuid', '33333333-3333-4333-8333-333333333333')->first();
+
+    // FleetOps builds brick geometries with x=latitude, y=longitude
+    expect($zone->getCentroid()->x())->toBe(1.32)
+        ->and($zone->location->getLat())->toBe(1.32)
+        ->and($zone->latitude)->toBe(1.32)
+        ->and($zone->longitude)->toBe(103.82);
+});

package/server/tests/Feature/Http/FleetOpsRouteRegistrationTest.php

@@ -0,0 +1,189 @@
+<?php
+
+use Illuminate\Support\Facades\Route;
+
+class FleetOpsFeatureRouteEntry
+{
+    public function __construct(private array &$route)
+    {
+    }
+
+    public function middleware(array|string $middleware): self
+    {
+        $this->route['middleware'] = is_array($middleware) ? $middleware : [$middleware];
+
+        return $this;
+    }
+}
+
+class FleetOpsFeatureRouteRecorder
+{
+    public array $routes   = [];
+    public array $groups   = [];
+    private array $pending = [];
+    private array $stack   = [];
+
+    public function prefix(?string $prefix): self
+    {
+        $this->pending['prefix'] = $prefix;
+
+        return $this;
+    }
+
+    public function namespace(string $namespace): self
+    {
+        $this->pending['namespace'] = $namespace;
+
+        return $this;
+    }
+
+    public function middleware(array|string $middleware): self
+    {
+        $this->pending['middleware'] = is_array($middleware) ? $middleware : [$middleware];
+
+        return $this;
+    }
+
+    public function group(array|callable $attributes, ?callable $callback = null): self
+    {
+        if (is_callable($attributes) && $callback === null) {
+            $callback   = $attributes;
+            $attributes = [];
+        }
+
+        $group          = array_merge($this->pending, $attributes);
+        $this->pending  = [];
+        $this->groups[] = $group;
+        $this->stack[]  = $group;
+
+        $callback?->__invoke($this);
+
+        array_pop($this->stack);
+
+        return $this;
+    }
+
+    public function get(string $uri, string|array $action): FleetOpsFeatureRouteEntry
+    {
+        return $this->record('GET', $uri, $action);
+    }
+
+    public function post(string $uri, string|array $action): FleetOpsFeatureRouteEntry
+    {
+        return $this->record('POST', $uri, $action);
+    }
+
+    public function put(string $uri, string|array $action): FleetOpsFeatureRouteEntry
+    {
+        return $this->record('PUT', $uri, $action);
+    }
+
+    public function patch(string $uri, string|array $action): FleetOpsFeatureRouteEntry
+    {
+        return $this->record('PATCH', $uri, $action);
+    }
+
+    public function delete(string $uri, string|array $action): FleetOpsFeatureRouteEntry
+    {
+        return $this->record('DELETE', $uri, $action);
+    }
+
+    public function any(string $uri, string|array $action): FleetOpsFeatureRouteEntry
+    {
+        return $this->record('ANY', $uri, $action);
+    }
+
+    public function match(array $methods, string $uri, string|array $action): FleetOpsFeatureRouteEntry
+    {
+        return $this->record(implode('|', array_map('strtoupper', $methods)), $uri, $action);
+    }
+
+    public function fleetbaseRoutes(string $resource, ?callable $callback = null): void
+    {
+        $this->record('FLEETBASE', $resource, $this->resourceController($resource, 'index'));
+
+        $this->stack[] = ['prefix' => $resource];
+        $callback?->__invoke($this, fn (string $method) => $this->resourceController($resource, $method));
+        array_pop($this->stack);
+    }
+
+    private function record(string $method, string $uri, string|array $action): FleetOpsFeatureRouteEntry
+    {
+        $prefixes = array_values(array_filter(array_map(
+            fn (array $group) => $group['prefix'] ?? null,
+            $this->stack,
+        ), fn ($prefix) => is_string($prefix) && $prefix !== ''));
+
+        $this->routes[] = [
+            'method' => $method,
+            'uri'    => implode('/', [...$prefixes, $uri]),
+            'action' => $action,
+            'groups' => $this->stack,
+        ];
+
+        return new FleetOpsFeatureRouteEntry($this->routes[array_key_last($this->routes)]);
+    }
+
+    private function resourceController(string $resource, string $method): string
+    {
+        $controller = str($resource)->singular()->camel()->ucfirst()->append('Controller')->toString();
+
+        return $controller . '@' . $method;
+    }
+}
+
+function fleetopsFeatureRecordedRoutes(): FleetOpsFeatureRouteRecorder
+{
+    config()->set('fleetops.api.routing.prefix', 'fleet-ops');
+    config()->set('fleetops.api.routing.internal_prefix', 'int');
+
+    $recorder = new FleetOpsFeatureRouteRecorder();
+    Route::swap($recorder);
+
+    require dirname(__DIR__, 3) . '/src/routes.php';
+
+    return $recorder;
+}
+
+test('fleetops internal resource route callbacks are registered with specialized endpoints', function () {
+    $recorder = fleetopsFeatureRecordedRoutes();
+    $routes   = collect($recorder->routes);
+
+    expect($routes->pluck('action')->all())
+        ->toContain('ContactController@convertToVendor')
+        ->toContain('DriverController@scheduleItems')
+        ->toContain('FleetController@assignVehicle')
+        ->toContain('FuelProviderConnectionController@testCredentials')
+        ->toContain('OrderController@bulkDispatch')
+        ->toContain('PlaceController@geocode')
+        ->toContain('TelematicController@testConnection')
+        ->toContain('MaintenanceScheduleController@calendarFeed')
+        ->toContain('MaintenanceController@addLineItem')
+        ->toContain('PartController@import');
+
+    expect($routes->pluck('uri')->all())
+        ->toContain('fleet-ops/int/v1/drivers/{id}/schedule-items')
+        ->toContain('fleet-ops/int/v1/orders/bulk-dispatch')
+        ->toContain('fleet-ops/int/v1/places/lookup')
+        ->toContain('fleet-ops/int/v1/telematics/{id}/devices')
+        ->toContain('fleet-ops/int/v1/maintenance-schedules/calendar-feed')
+        ->toContain('fleet-ops/int/v1/maintenances/{id}/line-items');
+});
+
+test('fleetops compatibility routes are registered when public prefix is configured', function () {
+    $recorder = fleetopsFeatureRecordedRoutes();
+    $routes   = collect($recorder->routes);
+
+    expect($routes->pluck('action')->all())
+        ->toContain('IssueController@timeline')
+        ->toContain('VendorController@vendorPersonnels')
+        ->toContain('VendorController@addVendorPersonnel')
+        ->toContain('VendorController@removeVendorPersonnel')
+        ->toContain('ContactController@convertToVendor');
+
+    expect($routes->pluck('uri')->all())
+        ->toContain('int/v1/issues/{id}/timeline')
+        ->toContain('int/v1/vendors/{id}/personnels')
+        ->toContain('int/v1/vendors/{id}/personnels/{contact}')
+        ->toContain('int/v1/contacts/{id}/convert-to-vendor');
+});

package/server/tests/Feature/Http/Internal/AnalyticsControllerSeamsTest.php

@@ -0,0 +1,53 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\AnalyticsController;
+use Fleetbase\FleetOps\Support\Analytics\AbstractAnalytics;
+use Fleetbase\FleetOps\Support\Analytics\OrdersByStatus;
+use Fleetbase\Models\Company;
+use Illuminate\Http\Request;
+
+/**
+ * Covers the analytics controller's construction seam and its failure
+ * reporting. Every widget endpoint funnels through run(), which builds the
+ * widget through analyticsForCompany() and reports anything that escapes.
+ */
+
+// A real application always has this helper; the bare container the harness
+// builds does not, which is the only reason the report branch is ever skipped.
+if (!function_exists('report')) {
+    eval('function report($exception) { $GLOBALS["fleetopsAnalyticsReported"][] = $exception; }');
+}
+
+test('analytics widgets are constructed for the requesting company', function () {
+    $company = new Company();
+    $company->setRawAttributes(['uuid' => 'company-analytics-seam', 'name' => 'Analytics Co'], true);
+
+    $controller = (new ReflectionClass(AnalyticsController::class))->newInstanceWithoutConstructor();
+
+    $build = new ReflectionMethod(AnalyticsController::class, 'analyticsForCompany');
+    $build->setAccessible(true);
+
+    $analytics = $build->invoke($controller, OrdersByStatus::class, $company);
+
+    expect($analytics)->toBeInstanceOf(OrdersByStatus::class)
+        ->and($analytics)->toBeInstanceOf(AbstractAnalytics::class);
+});
+
+test('widget failures are reported and answered with a 500 naming the widget', function () {
+    $GLOBALS['fleetopsAnalyticsReported'] = [];
+
+    $controller = (new ReflectionClass(AnalyticsController::class))->newInstanceWithoutConstructor();
+
+    $run = new ReflectionMethod(AnalyticsController::class, 'run');
+    $run->setAccessible(true);
+
+    // The request carries no authenticated user, so building the widget fails
+    // inside run() — which is the path that reports and degrades to a 500
+    // rather than letting the exception reach the client.
+    $request  = Request::create('/int/v1/fleet-ops/analytics/orders-by-status', 'GET');
+    $response = $run->invoke($controller, $request, OrdersByStatus::class);
+
+    expect($response->getStatusCode())->toBe(500)
+        ->and($response->getData(true)['widget'])->toBe(OrdersByStatus::class)
+        ->and($GLOBALS['fleetopsAnalyticsReported'])->toHaveCount(1);
+});