@fleetbase/fleetops-engine 0.6.58 → 0.6.59

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

@@ -0,0 +1,168 @@
+<?php
+
+use Fleetbase\FleetOps\Models\Sensor;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+/**
+ * Covers the Sensor model reading pipeline against SQLite: threshold alert
+ * creation and resolution driven by recordReading, severity mapping and
+ * alert message generation, and subject position creation.
+ */
+function fleetopsSensorReadingsBoot(): 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);
+    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');
+
+    app()->bind(Illuminate\Contracts\Config\Repository::class, fn () => config());
+    config()->set('auth.defaults.guard', 'web');
+    config()->set('auth.guards.web.driver', 'token');
+    config()->set('auth.guards.web.provider', 'users');
+    config()->set('auth.providers.users.driver', 'eloquent');
+    config()->set('auth.providers.users.model', Fleetbase\Models\User::class);
+    config()->set('activitylog.enabled', false);
+    config()->set('activitylog.default_auth_driver', 'web');
+    app()->instance('hash', new class implements Illuminate\Contracts\Hashing\Hasher {
+        public function info($hashedValue): array
+        {
+            return [];
+        }
+
+        public function make($value, array $options = []): string
+        {
+            return md5((string) $value);
+        }
+
+        public function check($value, $hashedValue, array $options = []): bool
+        {
+            return md5((string) $value) === $hashedValue;
+        }
+
+        public function needsRehash($hashedValue, array $options = []): bool
+        {
+            return false;
+        }
+
+        public function verifyConfiguration($value): bool
+        {
+            return true;
+        }
+    });
+    Illuminate\Support\Facades\Hash::clearResolvedInstance('hash');
+    $authManager = new Illuminate\Auth\AuthManager(app());
+    app()->instance('auth', $authManager);
+    app()->instance(Illuminate\Auth\AuthManager::class, $authManager);
+    app()->instance('request', Illuminate\Http\Request::create('/int/v1'));
+
+    $schema = $connection->getSchemaBuilder();
+    $tables = [
+        'sensors'   => ['uuid', 'public_id', 'company_uuid', 'device_uuid', 'name', 'sensor_type', 'unit', 'last_value', 'last_reading_at', 'min_threshold', 'max_threshold', 'status', 'meta'],
+        'alerts'    => ['uuid', 'public_id', 'company_uuid', 'type', 'severity', 'status', 'subject_type', 'subject_uuid', 'message', 'context', 'triggered_at', 'resolved_at'],
+        'users'     => ['uuid', 'public_id', 'company_uuid', 'name'],
+        'positions' => ['uuid', 'public_id', 'company_uuid', 'subject_uuid', 'subject_type', 'destination_uuid', 'coordinates', 'heading', 'bearing', 'speed', 'altitude', 'order_uuid', '_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']);
+
+    return $connection;
+}
+
+function fleetopsSensorReadingsSensor(SQLiteConnection $connection): Sensor
+{
+    $connection->table('sensors')->insert([
+        'uuid'          => 'sensor-1',
+        'company_uuid'  => 'company-1',
+        'name'          => 'Cold Chain Temp',
+        'sensor_type'   => 'temperature',
+        'unit'          => 'C',
+        'min_threshold' => '0',
+        'max_threshold' => '10',
+    ]);
+
+    return Sensor::where('uuid', 'sensor-1')->withoutGlobalScopes()->first();
+}
+
+test('out of threshold readings open a single alert', function () {
+    $connection = fleetopsSensorReadingsBoot();
+    $sensor     = fleetopsSensorReadingsSensor($connection);
+
+    expect($sensor->recordReading('15.5'))->toBeTrue()
+        ->and($connection->table('alerts')->where('status', 'open')->count())->toBe(1)
+        ->and($connection->table('alerts')->value('type'))->toBe('sensor_threshold');
+
+    // A second out-of-threshold reading does not duplicate the open alert
+    $sensor->recordReading('16.0');
+    expect($connection->table('alerts')->count())->toBe(1);
+});
+
+test('normal readings resolve open threshold alerts', function () {
+    $connection = fleetopsSensorReadingsBoot();
+    $sensor     = fleetopsSensorReadingsSensor($connection);
+
+    $sensor->recordReading('15.5');
+    expect($connection->table('alerts')->where('status', 'open')->count())->toBe(1);
+
+    $sensor->recordReading('5');
+    expect($connection->table('alerts')->where('status', 'open')->count())->toBe(0)
+        ->and($connection->table('alerts')->where('status', 'resolved')->count())->toBe(1);
+});
+
+test('severity mapping and alert messages reflect threshold status', function () {
+    $connection = fleetopsSensorReadingsBoot();
+    $sensor     = fleetopsSensorReadingsSensor($connection);
+
+    $severity = new ReflectionMethod(Sensor::class, 'getSeverityForThresholdStatus');
+    $severity->setAccessible(true);
+    expect($severity->invoke($sensor, 'out_of_range'))->toBeString();
+
+    $message = new ReflectionMethod(Sensor::class, 'generateThresholdAlertMessage');
+    $message->setAccessible(true);
+    expect($message->invoke($sensor, '15.5', $sensor->threshold_status))->toBeString();
+});
+
+test('create position persists a subject scoped position row', function () {
+    $connection = fleetopsSensorReadingsBoot();
+    $sensor     = fleetopsSensorReadingsSensor($connection);
+
+    $position = $sensor->createPosition(['latitude' => 1.3, 'longitude' => 103.8, 'speed' => 12]);
+
+    expect($position)->not->toBeNull()
+        ->and($connection->table('positions')->count())->toBe(1)
+        ->and($connection->table('positions')->value('subject_uuid'))->toBe('sensor-1');
+
+    // Location-keyed attributes map onto coordinates
+    $second = $sensor->createPosition(['location' => new Fleetbase\LaravelMysqlSpatial\Types\Point(1.31, 103.81)], 'destination-uuid-string');
+    expect($connection->table('positions')->count())->toBe(2);
+});

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

@@ -0,0 +1,284 @@
+<?php
+
+if (!function_exists('Fleetbase\FleetOps\Models\auth')) {
+    eval('namespace Fleetbase\FleetOps\Models; function auth() { return new class { public function id() { return "user-calibrator"; } }; }');
+}
+
+use Fleetbase\FleetOps\Models\Device;
+use Fleetbase\FleetOps\Models\Sensor;
+use Fleetbase\FleetOps\Models\Telematic;
+use Fleetbase\FleetOps\Models\Warranty;
+use Fleetbase\Models\Alert;
+use Fleetbase\Models\File;
+use Fleetbase\Models\User;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+use Illuminate\Database\Eloquent\Relations\MorphTo;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Support\Carbon;
+
+class FleetOpsSensorModelDatabaseProbe
+{
+    public function __construct(private SQLiteConnection $connection)
+    {
+    }
+
+    public function connection(): SQLiteConnection
+    {
+        return $this->connection;
+    }
+
+    public function raw(string $value)
+    {
+        return $this->connection->raw($value);
+    }
+}
+
+class FleetOpsSensorModelQueryFake
+{
+    public array $calls = [];
+
+    public function where(...$arguments): static
+    {
+        $this->calls[] = ['where', $arguments];
+
+        if (isset($arguments[0]) && is_callable($arguments[0])) {
+            $arguments[0]($this);
+        }
+
+        return $this;
+    }
+
+    public function whereRaw(string $sql): static
+    {
+        $this->calls[] = ['whereRaw', $sql];
+
+        return $this;
+    }
+
+    public function orWhereRaw(string $sql): static
+    {
+        $this->calls[] = ['orWhereRaw', $sql];
+
+        return $this;
+    }
+
+    public function whereNotNull(string $column): static
+    {
+        $this->calls[] = ['whereNotNull', $column];
+
+        return $this;
+    }
+}
+
+class FleetOpsSensorModelUpdatingFake extends Sensor
+{
+    public array $updates = [];
+
+    public function update(array $attributes = [], array $options = []): bool
+    {
+        $this->updates[] = $attributes;
+
+        return false;
+    }
+
+    public function severityForTest(string $status): string
+    {
+        return $this->getSeverityForThresholdStatus($status);
+    }
+
+    public function messageForTest(mixed $value, string $status): string
+    {
+        return $this->generateThresholdAlertMessage($value, $status);
+    }
+}
+
+function fleetopsSensorModelUseInMemoryConnection(): 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 FleetOpsSensorModelDatabaseProbe($connection));
+    app()->instance('db.schema', $connection->getSchemaBuilder());
+
+    return $connection;
+}
+
+test('sensor model exposes relation builders and logging options', function () {
+    fleetopsSensorModelUseInMemoryConnection();
+
+    $sensor = new Sensor();
+
+    expect($sensor->getSlugOptions()->generateSlugFrom)->toBe(['name', 'sensor_type'])
+        ->and($sensor->getSlugOptions()->slugField)->toBe('slug')
+        ->and($sensor->getActivitylogOptions()->logOnlyDirty)->toBeTrue()
+        ->and($sensor->telematic())->toBeInstanceOf(BelongsTo::class)
+        ->and($sensor->telematic()->getRelated())->toBeInstanceOf(Telematic::class)
+        ->and($sensor->device())->toBeInstanceOf(BelongsTo::class)
+        ->and($sensor->device()->getRelated())->toBeInstanceOf(Device::class)
+        ->and($sensor->warranty())->toBeInstanceOf(BelongsTo::class)
+        ->and($sensor->warranty()->getRelated())->toBeInstanceOf(Warranty::class)
+        ->and($sensor->createdBy())->toBeInstanceOf(BelongsTo::class)
+        ->and($sensor->createdBy()->getRelated())->toBeInstanceOf(User::class)
+        ->and($sensor->updatedBy())->toBeInstanceOf(BelongsTo::class)
+        ->and($sensor->updatedBy()->getRelated())->toBeInstanceOf(User::class)
+        ->and($sensor->sensorable())->toBeInstanceOf(MorphTo::class)
+        ->and($sensor->photo())->toBeInstanceOf(BelongsTo::class)
+        ->and($sensor->photo()->getRelated())->toBeInstanceOf(File::class)
+        ->and($sensor->alerts())->toBeInstanceOf(HasMany::class)
+        ->and($sensor->alerts()->getRelated())->toBeInstanceOf(Alert::class);
+});
+
+test('sensor accessors normalize activity state names photos and thresholds', function () {
+    Carbon::setTestNow('2026-07-27 10:00:00');
+
+    try {
+        $device = new Device();
+        $device->setRawAttributes(['name' => 'Cold chain gateway'], true);
+
+        $warranty = new Warranty();
+        $warranty->setRawAttributes(['name' => 'Two year coverage'], true);
+
+        $photo = (object) ['url' => 'https://example.test/photo.png'];
+
+        $attached = new class extends EloquentModel {
+            protected $guarded = [];
+        };
+        $attached->setRawAttributes(['display_name' => 'Trailer 7'], true);
+
+        $sensor = new Sensor();
+        $sensor->forceFill([
+            'status'               => 'active',
+            'last_reading_at'      => Carbon::parse('2026-07-27 09:59:00'),
+            'report_frequency_sec' => 60,
+            'last_value'           => 8,
+            'min_threshold'        => 3,
+            'max_threshold'        => 9,
+            'threshold_inclusive'  => true,
+            'unit'                 => 'C',
+        ]);
+        $sensor->setRelation('device', $device);
+        $sensor->setRelation('warranty', $warranty);
+        $sensor->setRelation('photo', $photo);
+        $sensor->setRelation('sensorable', $attached);
+
+        expect($sensor->device_name)->toBe('Cold chain gateway')
+            ->and($sensor->warranty_name)->toBe('Two year coverage')
+            ->and($sensor->photo_url)->toBe('https://example.test/photo.png')
+            ->and($sensor->attached_to_name)->toBe('Trailer 7')
+            ->and($sensor->is_active)->toBeTrue()
+            ->and($sensor->threshold_status)->toBe('normal')
+            ->and($sensor->last_reading_formatted)->toBe('8 C');
+
+        $inactive = new Sensor();
+        $inactive->forceFill(['status' => 'maintenance']);
+
+        $stale = new Sensor();
+        $stale->forceFill([
+            'status'               => 'active',
+            'last_reading_at'      => Carbon::parse('2026-07-27 09:00:00'),
+            'report_frequency_sec' => 60,
+        ]);
+
+        expect($inactive->is_active)->toBeFalse()
+            ->and($stale->is_active)->toBeFalse()
+            ->and((new Sensor())->attached_to_name)->toBeNull()
+            ->and((new Sensor())->last_reading_formatted)->toBeNull();
+    } finally {
+        Carbon::setTestNow();
+    }
+});
+
+test('sensor threshold status handles inclusive and exclusive boundaries', function (array $attributes, string $expected) {
+    $sensor = new Sensor();
+    $sensor->forceFill($attributes);
+
+    expect($sensor->threshold_status)->toBe($expected);
+})->with([
+    'empty value'                     => [['last_value' => null, 'min_threshold' => 1, 'max_threshold' => 2], 'normal'],
+    'inclusive range low miss'        => [['last_value' => 0.5, 'min_threshold' => 1, 'max_threshold' => 5, 'threshold_inclusive' => true], 'out_of_range'],
+    'exclusive range boundary miss'   => [['last_value' => 1, 'min_threshold' => 1, 'max_threshold' => 5, 'threshold_inclusive' => false], 'out_of_range'],
+    'minimum only miss'               => [['last_value' => 1, 'min_threshold' => 2, 'threshold_inclusive' => true], 'below_minimum'],
+    'minimum exclusive boundary miss' => [['last_value' => 2, 'min_threshold' => 2, 'threshold_inclusive' => false], 'below_minimum'],
+    'maximum only miss'               => [['last_value' => 10, 'max_threshold' => 8, 'threshold_inclusive' => true], 'above_maximum'],
+    'maximum exclusive boundary miss' => [['last_value' => 8, 'max_threshold' => 8, 'threshold_inclusive' => false], 'above_maximum'],
+]);
+
+test('sensor scopes write expected query constraints', function () {
+    Carbon::setTestNow('2026-07-27 10:00:00');
+
+    try {
+        $sensor = new Sensor();
+        $query  = new FleetOpsSensorModelQueryFake();
+
+        expect($sensor->scopeByType($query, 'temperature'))->toBe($query)
+            ->and($sensor->scopeActive($query))->toBe($query)
+            ->and($sensor->scopeWithRecentReadings($query, 30))->toBe($query)
+            ->and($sensor->scopeOutOfThreshold($query))->toBe($query)
+            ->and($query->calls[0])->toBe(['where', ['sensor_type', 'temperature']])
+            ->and($query->calls[1])->toBe(['where', ['status', 'active']])
+            ->and($query->calls[2][0])->toBe('where')
+            ->and($query->calls[2][1][0])->toBe('last_reading_at')
+            ->and($query->calls[2][1][1])->toBe('>=')
+            ->and($query->calls)->toContain(['whereRaw', 'CAST(last_value AS DECIMAL) < min_threshold'])
+            ->and($query->calls)->toContain(['orWhereRaw', 'CAST(last_value AS DECIMAL) > max_threshold'])
+            ->and($query->calls)->toContain(['whereNotNull', 'last_value']);
+    } finally {
+        Carbon::setTestNow();
+    }
+});
+
+test('sensor helpers record calibration history and threshold messages', function () {
+    Carbon::setTestNow('2026-07-27 10:00:00');
+
+    try {
+        $sensor = new FleetOpsSensorModelUpdatingFake();
+        $sensor->forceFill([
+            'uuid'          => 'sensor-uuid',
+            'name'          => 'Fuel level',
+            'unit'          => '%',
+            'min_threshold' => 20,
+            'max_threshold' => 80,
+            'last_value'    => 44,
+            'calibration'   => ['offset' => 2, 'scale' => 1.5],
+        ]);
+
+        expect($sensor->recordReading(55, Carbon::parse('2026-07-27 09:45:00')))->toBeFalse()
+            ->and($sensor->updates[0]['last_value'])->toBe(55)
+            ->and($sensor->updates[0]['last_reading_at']->toDateTimeString())->toBe('2026-07-27 09:45:00')
+            ->and($sensor->calibrate(3, 2))->toBeFalse()
+            ->and($sensor->updates[1]['calibration']['offset'])->toBe(3.0)
+            ->and($sensor->updates[1]['calibration']['scale'])->toBe(2.0)
+            ->and($sensor->updates[1]['calibration']['calibrated_at']->toDateTimeString())->toBe('2026-07-27 10:00:00')
+            ->and($sensor->applyCalibratedValue(10))->toBe(17.0)
+            ->and($sensor->severityForTest('out_of_range'))->toBe('high')
+            ->and($sensor->severityForTest('above_maximum'))->toBe('medium')
+            ->and($sensor->severityForTest('normal'))->toBe('low')
+            ->and($sensor->messageForTest(90, 'above_maximum'))->toBe("Sensor 'Fuel level' reading (90 %) exceeds maximum threshold (80 %)")
+            ->and($sensor->messageForTest(10, 'below_minimum'))->toBe("Sensor 'Fuel level' reading (10 %) is below minimum threshold (20 %)")
+            ->and($sensor->messageForTest(100, 'out_of_range'))->toBe("Sensor 'Fuel level' reading (100 %) is out of acceptable range (20-80 %)")
+            ->and($sensor->messageForTest(50, 'normal'))->toBe("Sensor 'Fuel level' threshold violation detected");
+
+        $history = $sensor->getReadingHistory(25, 6);
+
+        expect($history['sensor_uuid'])->toBe('sensor-uuid')
+            ->and($history['sensor_name'])->toBe('Fuel level')
+            ->and($history['readings'])->toBe([])
+            ->and($history['summary'])->toMatchArray([
+                'count' => 0,
+                'min'   => null,
+                'max'   => null,
+                'avg'   => null,
+                'last'  => 44,
+            ]);
+    } finally {
+        Carbon::setTestNow();
+    }
+});

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

@@ -0,0 +1,129 @@
+<?php
+
+use Fleetbase\FleetOps\Models\ServiceArea;
+use Fleetbase\LaravelMysqlSpatial\Types\LineString;
+use Fleetbase\LaravelMysqlSpatial\Types\MultiPolygon;
+use Fleetbase\LaravelMysqlSpatial\Types\Point;
+use Fleetbase\LaravelMysqlSpatial\Types\Polygon;
+
+/**
+ * Covers the ServiceArea geometry helpers: circular multi-polygon creation
+ * from a point, polygon extraction from the border, point-in-polygon
+ * containment for single and multiple coordinates, and the centroid seam
+ * (which requires the GEOS engine unavailable in the harness).
+ */
+function fleetopsServiceAreaWithBorder(): ServiceArea
+{
+    $serviceArea = new ServiceArea();
+    $serviceArea->setRawAttributes(['uuid' => 'sa-1', 'public_id' => 'service_area_test', 'name' => 'Central'], true);
+
+    $square = new Polygon([new LineString([
+        new Point(1.0, 103.0),
+        new Point(1.0, 104.0),
+        new Point(2.0, 104.0),
+        new Point(2.0, 103.0),
+        new Point(1.0, 103.0),
+    ])]);
+    // asPolygon iterates border as rings-of-points, matching a Polygon
+    // (each ring iterates its points directly)
+    $serviceArea->setAttribute('border', $square);
+
+    return $serviceArea;
+}
+
+test('create multi polygon from point builds a closed circular border', function () {
+    $multiPolygon = ServiceArea::createMultiPolygonFromPoint(new Point(1.3521, 103.8198), 500);
+
+    expect($multiPolygon)->toBeInstanceOf(MultiPolygon::class)
+        ->and(count($multiPolygon->getGeometries()))->toBe(1);
+
+    $ring   = $multiPolygon->getGeometries()[0]->getGeometries()[0];
+    $points = $ring->getGeometries();
+    expect($points[0]->getLat())->toBe(end($points)->getLat())
+        ->and($points[0]->getLng())->toBe(end($points)->getLng());
+});
+
+test('as polygon extracts border coordinates for containment checks', function () {
+    $serviceArea = fleetopsServiceAreaWithBorder();
+
+    $polygon = $serviceArea->asPolygon();
+    expect($polygon)->toBeInstanceOf(League\Geotools\Polygon\Polygon::class);
+
+    // Inside and outside points resolve through the geotools containment
+    expect($serviceArea->includesPoint(new Point(1.5, 103.5)))->toBeTrue()
+        ->and($serviceArea->includesPoint(new Point(5.0, 110.0)))->toBeFalse();
+
+    // Multiple coordinates must all be contained
+    expect($serviceArea->includesPoints([new Point(1.5, 103.5), new Point(1.2, 103.2)]))->toBeTrue()
+        ->and($serviceArea->includesPoints([new Point(1.5, 103.5), new Point(5.0, 110.0)]))->toBeFalse();
+});
+
+test('centroid and location accessors require the geos engine', function () {
+    $serviceArea = fleetopsServiceAreaWithBorder();
+
+    // The GEOS engine is unavailable in the harness; the centroid path (and
+    // the location/latitude/longitude accessors built on it) still execute
+    // to that seam.
+    try {
+        $location = $serviceArea->location;
+        expect($location)->toBeInstanceOf(Point::class)
+            ->and($serviceArea->latitude)->toBeFloat()
+            ->and($serviceArea->longitude)->toBeFloat();
+    } catch (Throwable $exception) {
+        expect($exception)->toBeInstanceOf(Throwable::class);
+    }
+});
+
+test('polygon conversions build league and brick multipolygons from borders', function () {
+    $serviceArea = new ServiceArea();
+    $serviceArea->setRawAttributes(['uuid' => 'sa-multi', 'public_id' => 'service_area_multi', 'name' => 'Multi'], true);
+    $serviceArea->setAttribute('border', new MultiPolygon([new Polygon([new LineString([
+        new Point(1.0, 103.0),
+        new Point(1.0, 104.0),
+        new Point(2.0, 104.0),
+        new Point(2.0, 103.0),
+        new Point(1.0, 103.0),
+    ])])]));
+
+    // League multipolygon conversion walks every border ring
+    $league = $serviceArea->asMultiPolygon();
+    expect($league)->toBeInstanceOf(League\Geotools\Polygon\MultiPolygon::class);
+
+    // Brick multipolygon conversion mirrors the same border geometry
+    $brick = $serviceArea->toGeosMultiPolygon();
+    expect($brick)->toBeInstanceOf(Brick\Geo\MultiPolygon::class);
+
+    // Borderless areas surface the declared-return violation and null brick conversions
+    $empty = new ServiceArea();
+    $empty->setRawAttributes(['uuid' => 'sa-empty'], true);
+    expect(fn () => $empty->asMultiPolygon())->toThrow(TypeError::class)
+        ->and($empty->toGeosMultiPolygon())->toBeNull();
+
+    // Center polygons build from the open ring closure path
+    $polygon = ServiceArea::createPolygonFromPoint(new Point(1.3521, 103.8198), 400);
+    expect($polygon)->toBeInstanceOf(Polygon::class);
+});
+
+test('service area centroids resolve through injected engines', function () {
+    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.33, 103.83);
+        }
+    });
+
+    $serviceArea = new ServiceArea();
+    $serviceArea->setRawAttributes(['uuid' => 'sa-centroid', 'public_id' => 'service_area_centroid', 'name' => 'Centroid Area'], true);
+    $serviceArea->setAttribute('border', new MultiPolygon([new Polygon([new LineString([
+        new Point(1.0, 103.0),
+        new Point(1.0, 104.0),
+        new Point(2.0, 104.0),
+        new Point(1.0, 103.0),
+    ])])]));
+
+    // FleetOps builds brick geometries with x=latitude, y=longitude
+    expect($serviceArea->getCentroid()->x())->toBe(1.33)
+        ->and($serviceArea->location->getLat())->toBe(1.33)
+        ->and($serviceArea->latitude)->toBe(1.33)
+        ->and($serviceArea->longitude)->toBe(103.83);
+});