@fleetbase/fleetops-engine 0.6.58 → 0.6.60

package/server/tests/RouteRegistrationExecutionTest.php

@@ -0,0 +1,178 @@
+<?php
+
+use Illuminate\Support\Facades\Route;
+
+class FleetOpsRouteRecorder
+{
+    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'] = $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): void
+    {
+        $this->record('GET', $uri, $action);
+    }
+
+    public function post(string $uri, string|array $action): void
+    {
+        $this->record('POST', $uri, $action);
+    }
+
+    public function put(string $uri, string|array $action): void
+    {
+        $this->record('PUT', $uri, $action);
+    }
+
+    public function patch(string $uri, string|array $action): void
+    {
+        $this->record('PATCH', $uri, $action);
+    }
+
+    public function delete(string $uri, string|array $action): void
+    {
+        $this->record('DELETE', $uri, $action);
+    }
+
+    public function any(string $uri, string|array $action): void
+    {
+        $this->record('ANY', $uri, $action);
+    }
+
+    public function match(array $methods, string $uri, string|array $action): void
+    {
+        $this->record(implode('|', array_map('strtoupper', $methods)), $uri, $action);
+    }
+
+    public function fleetbaseRoutes(string $resource): void
+    {
+        $this->record('FLEETBASE', $resource, 'fleetbaseRoutes');
+    }
+
+    private function record(string $method, string $uri, string|array $action): void
+    {
+        $prefixes = array_values(array_filter(array_map(
+            fn (array $group) => $group['prefix'] ?? null,
+            $this->stack,
+        ), fn ($prefix) => $prefix !== null && $prefix !== ''));
+
+        $this->routes[] = [
+            'method' => $method,
+            'uri'    => implode('/', [...$prefixes, $uri]),
+            'action' => $action,
+            'groups' => $this->stack,
+        ];
+    }
+}
+
+function fleetOpsRecordedRoutes(): FleetOpsRouteRecorder
+{
+    $recorder = new FleetOpsRouteRecorder();
+    Route::swap($recorder);
+
+    require dirname(__DIR__) . '/src/routes.php';
+
+    return $recorder;
+}
+
+test('fleetops route file registers public internal analytics metrics and hub routes', function () {
+    $recorder = fleetOpsRecordedRoutes();
+    $actions  = array_column($recorder->routes, 'action');
+    $uris     = array_column($recorder->routes, 'uri');
+
+    expect($actions)
+        ->toContain('DriverController@login')
+        ->toContain('CustomerController@createOrder')
+        ->toContain('FuelTransactionController@matchVehicle')
+        ->toContain('OrderController@dispatchOrder')
+        ->toContain('AnalyticsController@operationsPulse')
+        ->toContain('MetricsController@show')
+        ->toContain('HubController@resources')
+        ->toContain('HubController@maintenance')
+        ->toContain('TelematicWebhookController@handle')
+        ->toContain('TelematicWebhookController@ingest')
+        ->toContain('fleetbaseRoutes');
+
+    expect($uris)
+        ->toContain('v1/drivers/login')
+        ->toContain('v1/customers/orders')
+        ->toContain('v1/fuel-transactions/{id}/match-vehicle')
+        ->toContain('int/v1/fleet-ops/analytics/operations-pulse')
+        ->toContain('int/v1/fleet-ops/metrics/{slug}')
+        ->toContain('int/v1/fleet-ops/hubs/resources');
+});
+
+test('fleetops route file wires route groups with expected middleware and namespaces', function () {
+    $recorder = fleetOpsRecordedRoutes();
+
+    expect($recorder->groups)->toContainEqual([
+        'prefix'    => null,
+        'namespace' => 'Fleetbase\FleetOps\Http\Controllers',
+    ]);
+
+    expect($recorder->groups)->toContainEqual([
+        'prefix'     => 'v1',
+        'middleware' => ['fleetbase.api', Fleetbase\FleetOps\Http\Middleware\TransformLocationMiddleware::class],
+        'namespace'  => 'Api\v1',
+    ]);
+
+    expect($recorder->groups)->toContainEqual([
+        'prefix'    => 'int',
+        'namespace' => 'Internal',
+    ]);
+
+    expect($recorder->groups)->toContainEqual([
+        'prefix'    => 'v1/fleet-ops',
+        'namespace' => 'v1',
+    ]);
+
+    expect($recorder->groups)->toContainEqual([
+        'prefix'     => 'v1',
+        'namespace'  => 'v1',
+        'middleware' => [
+            'fleetbase.protected',
+            Fleetbase\FleetOps\Http\Middleware\TransformLocationMiddleware::class,
+            Fleetbase\FleetOps\Http\Middleware\SetupDriverSession::class,
+        ],
+    ]);
+});

package/server/tests/RouteSequencingEngineTest.php

@@ -0,0 +1,179 @@
+<?php
+
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Orchestration\Engines\RouteSequencingEngine;
+use Illuminate\Support\Collection;
+
+function routeSequencingLocation(float $lat, float $lng): object
+{
+    return new class($lat, $lng) {
+        public function __construct(private float $lat, private float $lng)
+        {
+        }
+
+        public function getLat(): float
+        {
+            return $this->lat;
+        }
+
+        public function getLng(): float
+        {
+            return $this->lng;
+        }
+    };
+}
+
+function routeSequencingPlace(float|string|null $lat, float|string|null $lng): object
+{
+    return (object) [
+        'lat' => $lat,
+        'lng' => $lng,
+    ];
+}
+
+function routeSequencingPayload($pickup = null, $dropoff = null, array $waypoints = [], bool $multiDrop = false): object
+{
+    return new class($pickup, $dropoff, $waypoints, $multiDrop) {
+        public ?string $pickup_uuid;
+        public ?string $dropoff_uuid;
+        public Collection $waypoints;
+
+        public function __construct(public $pickup, public $dropoff, array $waypoints, bool $multiDrop)
+        {
+            $this->pickup_uuid  = $multiDrop ? null : 'pickup-uuid';
+            $this->dropoff_uuid = $multiDrop ? null : 'dropoff-uuid';
+            $this->waypoints    = collect($waypoints);
+        }
+    };
+}
+
+function routeSequencingWaypoint(int $order, object $place): object
+{
+    return (object) [
+        'order' => $order,
+        'place' => $place,
+    ];
+}
+
+function routeSequencingOrder(string $publicId, ?string $vehicleUuid = null, $payload = null, $vehicle = null): Order
+{
+    $order                        = new Order();
+    $order->public_id             = $publicId;
+    $order->vehicle_assigned_uuid = $vehicleUuid;
+
+    if ($payload) {
+        $order->setRelation('payload', $payload);
+    }
+
+    if ($vehicle) {
+        $order->setRelation('vehicle', $vehicle);
+    }
+
+    return $order;
+}
+
+function routeSequencingInvoke(RouteSequencingEngine $engine, string $method, array $arguments = [])
+{
+    $reflection = new ReflectionMethod($engine, $method);
+    $reflection->setAccessible(true);
+
+    return $reflection->invokeArgs($engine, $arguments);
+}
+
+test('route sequencing preserves vehicle assignment and orders stops by nearest eligible location', function () {
+    $engine = new RouteSequencingEngine();
+    $driver = (object) [
+        'public_id' => 'driver_public',
+        'location'  => routeSequencingLocation(1.00, 103.00),
+    ];
+    $vehicle = (object) [
+        'public_id' => 'vehicle_public',
+        'driver'    => $driver,
+        'location'  => routeSequencingLocation(1.50, 103.50),
+    ];
+
+    $nearOrder = routeSequencingOrder(
+        'order_near',
+        'vehicle-uuid',
+        routeSequencingPayload(
+            routeSequencingPlace(1.01, 103.01),
+            routeSequencingPlace(1.02, 103.02)
+        ),
+        $vehicle
+    );
+    $farOrder = routeSequencingOrder(
+        'order_far',
+        'vehicle-uuid',
+        routeSequencingPayload(
+            routeSequencingPlace(2.00, 104.00),
+            routeSequencingPlace(2.10, 104.10)
+        ),
+        $vehicle
+    );
+    $unassigned = routeSequencingOrder('order_unassigned');
+
+    $result = $engine->sequence(collect([$farOrder, $unassigned, $nearOrder]));
+
+    expect($result['unassigned'])->toBe(['order_unassigned'])
+        ->and($result['summary'])->toMatchArray([
+            'engine'     => 'route_sequencing',
+            'assigned'   => 2,
+            'unassigned' => 1,
+        ]);
+
+    $assignments = collect($result['assignments'])->keyBy('order_id');
+    expect($assignments['order_near'])->toMatchArray([
+        'vehicle_id' => 'vehicle_public',
+        'driver_id'  => 'driver_public',
+        'sequence'   => 1,
+    ]);
+    expect($assignments['order_far']['sequence'])->toBeGreaterThan($assignments['order_near']['sequence']);
+});
+
+test('route sequencing handles multi drop waypoints and missing vehicle relations', function () {
+    $engine = new RouteSequencingEngine();
+    $order  = routeSequencingOrder(
+        'order_multi',
+        'vehicle-missing-relation',
+        routeSequencingPayload(null, null, [
+            routeSequencingWaypoint(2, routeSequencingPlace(1.20, 103.20)),
+            routeSequencingWaypoint(1, routeSequencingPlace(1.10, 103.10)),
+        ], true)
+    );
+    $order->setRelation('vehicle', null);
+
+    $result = $engine->sequence(collect([$order]));
+
+    expect($result['assignments'])->toHaveCount(1)
+        ->and($result['assignments'][0])->toMatchArray([
+            'order_id'   => 'order_multi',
+            'vehicle_id' => 'vehicle-missing-relation',
+            'driver_id'  => null,
+            'sequence'   => 1,
+        ])
+        ->and($result['summary']['assigned'])->toBe(1);
+});
+
+test('route sequencing protected helpers cover precedence fallback and distances', function () {
+    $engine = new RouteSequencingEngine();
+    $order  = routeSequencingOrder(
+        'order_dropoff_only',
+        'vehicle-uuid',
+        routeSequencingPayload(
+            routeSequencingPlace(null, null),
+            routeSequencingPlace(1.25, 103.25)
+        )
+    );
+
+    $sequence = routeSequencingInvoke($engine, '_sequenceOrdersForVehicle', [[$order], null, null]);
+
+    expect($sequence)->toHaveCount(1)
+        ->and($sequence[0])->toMatchArray([
+            'order_public_id' => 'order_dropoff_only',
+            'type'            => 'dropoff',
+        ]);
+
+    $distance = routeSequencingInvoke($engine, '_haversine', [1.00, 103.00, 1.01, 103.01]);
+    expect($distance)->toBeGreaterThan(0.0)
+        ->and(routeSequencingInvoke($engine, '_sequenceOrdersForVehicle', [[], null, null]))->toBe([]);
+});

package/server/tests/RulesAndCastsTest.php

@@ -0,0 +1,246 @@
+<?php
+
+use Fleetbase\FleetOps\Casts\MultiPolygon;
+use Fleetbase\FleetOps\Casts\OrderConfigEntities;
+use Fleetbase\FleetOps\Casts\Point as PointCast;
+use Fleetbase\FleetOps\Casts\Polygon;
+use Fleetbase\FleetOps\Rules\ComputableAlgo;
+use Fleetbase\FleetOps\Rules\CustomerIdOrDetails;
+use Fleetbase\FleetOps\Rules\ResolvablePoint;
+use Fleetbase\FleetOps\Rules\ResolvableVehicle;
+use Fleetbase\LaravelMysqlSpatial\Eloquent\SpatialExpression;
+use Fleetbase\LaravelMysqlSpatial\Types\MultiPolygon as SpatialMultiPolygon;
+use Fleetbase\LaravelMysqlSpatial\Types\Point;
+use Fleetbase\LaravelMysqlSpatial\Types\Polygon as SpatialPolygon;
+use Illuminate\Database\Query\Expression;
+
+class FleetOpsOrderConfigEntitiesCastProbe extends OrderConfigEntities
+{
+    public array $photoUrls = [];
+
+    protected function photoUrlFor(string $photoUuid): ?string
+    {
+        return $this->photoUrls[$photoUuid] ?? null;
+    }
+}
+
+test('customer detail validation accepts useful inline customer payloads', function () {
+    $rule = new CustomerIdOrDetails();
+
+    expect($rule->passes('customer', ['name' => 'Jane Customer']))->toBeTrue()
+        ->and($rule->passes('customer', ['email' => 'jane@example.test']))->toBeTrue()
+        ->and($rule->passes('customer', ['name' => 'Jane Customer', 'email' => 'jane@example.test']))->toBeTrue()
+        ->and($rule->message())->toBe('The :attribute is invalid.');
+});
+
+test('customer detail validation reports specific shape errors', function () {
+    $rule = new CustomerIdOrDetails();
+
+    expect($rule->passes('customer', []))->toBeFalse()
+        ->and($rule->message())->toBe('The :attribute must have at least a name and email.')
+        ->and($rule->passes('customer', ['email' => 'not-an-email']))->toBeFalse()
+        ->and($rule->message())->toBe('The :attribute email must be a valid email address.')
+        ->and($rule->passes('customer', ['name' => '   ']))->toBeFalse()
+        ->and($rule->message())->toBe('The :attribute name must be a non-empty string.')
+        ->and($rule->passes('customer', false))->toBeFalse()
+        ->and($rule->message())->toBe('The :attribute must be either a string (customer ID) or an object with name and/or email.');
+});
+
+test('customer id validation resolves string identifiers against the customer tables', function () {
+    $connection = new Illuminate\Database\SQLiteConnection(new PDO('sqlite::memory:'));
+    $resolver   = new Illuminate\Database\ConnectionResolver(['default' => $connection, 'mysql' => $connection, 'sqlite' => $connection]);
+    $resolver->setDefaultConnection('mysql');
+    Illuminate\Database\Eloquent\Model::setConnectionResolver($resolver);
+    app()->instance('db', $resolver);
+    // ExistsInAny probes Schema::hasColumn before querying, which resolves the
+    // schema builder out of the container rather than off the connection.
+    app()->instance('db.schema', $connection->getSchemaBuilder());
+    Illuminate\Support\Facades\DB::clearResolvedInstance('db');
+    Illuminate\Support\Facades\Schema::clearResolvedInstance('db.schema');
+    config()->set('database.default', 'mysql');
+
+    foreach (['vendors', 'contacts'] as $table) {
+        $connection->getSchemaBuilder()->create($table, function ($blueprint) {
+            $blueprint->increments('id');
+            $blueprint->string('uuid')->nullable();
+            $blueprint->string('public_id')->nullable();
+        });
+    }
+    $connection->table('contacts')->insert(['uuid' => 'contact-rule-1', 'public_id' => 'contact_ruleone']);
+
+    // A scalar customer is an identifier rather than an inline payload, so it
+    // is delegated to an existence check across the customer-bearing tables.
+    $rule = new CustomerIdOrDetails();
+
+    expect($rule->passes('customer', 'contact_ruleone'))->toBeTrue()
+        ->and($rule->passes('customer', 'contact_missing'))->toBeFalse();
+});
+
+test('computable algorithm rule delegates to algorithm evaluation', function () {
+    $rule = new ComputableAlgo();
+
+    expect($rule->passes('algorithm', '{base_fee} + max({distance_km}, 10)'))->toBeTrue()
+        ->and($rule->passes('algorithm', '{base_fee} +'))->toBeFalse()
+        ->and($rule->message())->toBe('Algorithm provided is not computable.');
+});
+
+test('resolvable vehicle extracts supported identifier shapes without hitting the database for empty values', function () {
+    $rule   = new ResolvableVehicle();
+    $method = new ReflectionMethod($rule, 'extractIdentifier');
+    $method->setAccessible(true);
+
+    expect($method->invoke($rule, 'vehicle_123'))->toBe('vehicle_123')
+        ->and($method->invoke($rule, ['id' => 'vehicle_id']))->toBe('vehicle_id')
+        ->and($method->invoke($rule, ['public_id' => 'vehicle_public']))->toBe('vehicle_public')
+        ->and($method->invoke($rule, ['uuid' => 'vehicle_uuid']))->toBe('vehicle_uuid')
+        ->and($method->invoke($rule, (object) ['public_id' => 'vehicle_object']))->toBe('vehicle_object')
+        ->and($method->invoke($rule, false))->toBeNull()
+        ->and($rule->passes('vehicle', null))->toBeTrue()
+        ->and($rule->getResolved())->toBeNull()
+        ->and($rule->message())->toBe('The :attribute must be a valid vehicle public ID, UUID, or vehicle object.');
+});
+
+test('resolvable point accepts point instances and rejects unresolvable values', function () {
+    $rule = new ResolvablePoint();
+
+    expect($rule->passes('location', new Point(1.3, 103.8)))->toBeTrue()
+        ->and($rule->passes('location', 'not-a-point'))->toBeFalse()
+        ->and($rule->message())->toBe('The :attribute must be a valid GeoJSON Point or a type (Place ID) that can be resolved to a Point.');
+});
+
+test('order config entity cast serializes arrays for storage', function () {
+    $cast = new OrderConfigEntities();
+    $data = [
+        ['name' => 'Parcel', 'type' => 'parcel'],
+        ['name' => 'Pallet', 'type' => 'pallet'],
+    ];
+
+    expect($cast->set(new stdClass(), 'entities', $data, []))->toBe(json_encode($data));
+});
+
+test('order config entity cast decodes entities and enriches available photos', function () {
+    $cast            = new FleetOpsOrderConfigEntitiesCastProbe();
+    $cast->photoUrls = [
+        'photo-uuid' => 'https://cdn.test/photo.png',
+    ];
+
+    $entities = [
+        ['name' => 'Parcel', 'photo_uuid' => 'photo-uuid'],
+        ['name' => 'Pallet', 'photo_uuid' => 'missing-photo'],
+        ['name' => 'Envelope'],
+    ];
+
+    expect($cast->get(new stdClass(), 'entities', json_encode($entities), []))->toBe([
+        ['name' => 'Parcel', 'photo_uuid' => 'photo-uuid', 'photo_url' => 'https://cdn.test/photo.png'],
+        ['name' => 'Pallet', 'photo_uuid' => 'missing-photo'],
+        ['name' => 'Envelope'],
+    ])
+        ->and($cast->get(new stdClass(), 'entities', '"not-an-array"', []))->toBe('not-an-array');
+});
+
+test('polygon casts reject unsupported values with helpful field names', function () {
+    $model             = new stdClass();
+    $model->geometries = [];
+
+    expect(fn () => (new Polygon())->set($model, 'border', 'invalid', []))
+        ->toThrow(Exception::class, 'Invalid Polygon provided for border')
+        ->and(fn () => (new MultiPolygon())->set($model, 'coverage_area', 'invalid', []))
+        ->toThrow(Exception::class, 'Invalid MultiPolygon provided for coverage_area');
+});
+
+test('spatial casts preserve valid geometry expressions and geojson payloads', function () {
+    $model             = new stdClass();
+    $model->geometries = [];
+
+    $polygonGeoJson = [
+        'type'        => 'Polygon',
+        'coordinates' => [[
+            [106.0, 47.0],
+            [107.0, 47.0],
+            [107.0, 48.0],
+            [106.0, 47.0],
+        ]],
+    ];
+    $multiPolygonGeoJson = [
+        'type'        => 'MultiPolygon',
+        'coordinates' => [[[
+            [106.0, 47.0],
+            [107.0, 47.0],
+            [107.0, 48.0],
+            [106.0, 47.0],
+        ]]],
+    ];
+    $pointGeoJson = [
+        'type'        => 'Point',
+        'coordinates' => [106.9338169, 47.9131423],
+    ];
+
+    $polygonCast      = new Polygon();
+    $multiPolygonCast = new MultiPolygon();
+    $pointCast        = new PointCast();
+    $polygon          = SpatialPolygon::fromJson(json_encode($polygonGeoJson));
+    $multiPolygon     = SpatialMultiPolygon::fromJson(json_encode($multiPolygonGeoJson));
+    $pointExpression  = new SpatialExpression(new Point(47.9131423, 106.9338169));
+    $sqlExpression    = new Expression("ST_PointFromText('POINT(106.9338169 47.9131423)')");
+
+    expect($polygonCast->get($model, 'border', 'stored-polygon', []))->toBe('stored-polygon')
+        ->and($polygonCast->set($model, 'border', $polygon, []))->toBe($polygon)
+        ->and($polygonCast->set($model, 'border_expression', new SpatialExpression($polygon), []))->toBeInstanceOf(SpatialExpression::class)
+        ->and($polygonCast->set($model, 'border_geojson', $polygonGeoJson, []))->toBeInstanceOf(SpatialPolygon::class)
+        ->and($multiPolygonCast->get($model, 'coverage', 'stored-multipolygon', []))->toBe('stored-multipolygon')
+        ->and($multiPolygonCast->set($model, 'coverage', $multiPolygon, []))->toBeInstanceOf(SpatialExpression::class)
+        ->and($multiPolygonCast->set($model, 'coverage_expression', new SpatialExpression($multiPolygon), []))->toBeInstanceOf(SpatialExpression::class)
+        ->and($multiPolygonCast->set($model, 'coverage_geojson', $multiPolygonGeoJson, []))->toBeInstanceOf(SpatialMultiPolygon::class)
+        ->and($pointCast->get($model, 'location', 'stored-point', []))->toBe('stored-point')
+        ->and($pointCast->set($model, 'location_sql', $sqlExpression, []))->toBe($sqlExpression)
+        ->and($pointCast->set($model, 'location_geometry', new Point(47.9131423, 106.9338169), []))->toBeInstanceOf(SpatialExpression::class)
+        ->and($pointCast->set($model, 'location_geojson', $pointGeoJson, []))->toBeInstanceOf(SpatialExpression::class)
+        ->and($pointCast->set($model, 'location_coordinates', '47.9131423,106.9338169', []))->toBeInstanceOf(Point::class)
+        ->and($pointCast->set($model, 'location_expression', $pointExpression, []))->toBe($pointExpression)
+        ->and($pointCast->set($model, 'location_empty', 'notcoordinates', []))->toBeInstanceOf(SpatialExpression::class);
+});
+
+test('spatial cast output expands into query bindings differently per cast', function () {
+    $model             = new stdClass();
+    $model->geometries = [];
+
+    $ring = [[
+        [103.85, 1.35],
+        [103.95, 1.35],
+        [103.95, 1.45],
+        [103.85, 1.35],
+    ]];
+
+    // Writes bind through BaseBuilder, whose cleanBindings() expands a
+    // SpatialExpression into the two bindings ST_GeomFromText(?, ?) expects.
+    // A bare geometry is passed straight through as a single binding instead.
+    // This matters on updates: SpatialTrait overrides performInsert() but not
+    // performUpdate(), so on update whatever the cast returned is bound as-is.
+    // Point and MultiPolygon wrap; Polygon does not. This test pins that
+    // divergence rather than asserting it away — see the PR notes.
+    $builder = (new ReflectionClass(Fleetbase\LaravelMysqlSpatial\Eloquent\BaseBuilder::class))->newInstanceWithoutConstructor();
+
+    $wrapped = [
+        'point'        => (new PointCast())->set($model, 'location', new Point(1.35, 103.85), []),
+        'multipolygon' => (new MultiPolygon())->set($model, 'coverage', SpatialMultiPolygon::fromJson(json_encode([
+            'type' => 'MultiPolygon', 'coordinates' => [$ring],
+        ])), []),
+    ];
+
+    foreach ($wrapped as $label => $castOutput) {
+        expect($castOutput)->toBeInstanceOf(SpatialExpression::class);
+
+        $bindings = $builder->cleanBindings([$castOutput]);
+        expect($bindings)->toHaveCount(2)
+            ->and($bindings[0])->toBeString()
+            ->and($bindings[1])->toBeInt();
+    }
+
+    // Polygon hands back the geometry itself, so it survives as one binding
+    $polygonOutput = (new Polygon())->set($model, 'border', SpatialPolygon::fromJson(json_encode([
+        'type' => 'Polygon', 'coordinates' => $ring,
+    ])), []);
+
+    expect($polygonOutput)->toBeInstanceOf(SpatialPolygon::class)
+        ->and($builder->cleanBindings([$polygonOutput]))->toHaveCount(1);
+});