@fleetbase/fleetops-engine 0.6.58 → 0.6.60

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

@@ -0,0 +1,153 @@
+<?php
+
+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 $key === "fleetbase.connection.db" ? "mysql" : $default; }');
+}
+
+if (!function_exists('session')) {
+    function session($key = null, $default = null)
+    {
+        static $values = [];
+
+        if (is_array($key)) {
+            $values = array_merge($values, $key);
+
+            return null;
+        }
+
+        return $values[$key] ?? $default;
+    }
+}
+
+use Fleetbase\FleetOps\Models\Fleet;
+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\HasManyThrough;
+use Illuminate\Database\SQLiteConnection;
+use Spatie\Activitylog\LogOptions;
+use Spatie\Sluggable\SlugOptions;
+
+class FleetOpsFleetUnitCountingRelationFake
+{
+    public array $wheres = [];
+
+    public function __construct(private int $count)
+    {
+    }
+
+    public function where(string $column, mixed $value): self
+    {
+        $this->wheres[] = [$column, $value];
+
+        return $this;
+    }
+
+    public function count(): int
+    {
+        return $this->count;
+    }
+}
+
+class FleetOpsFleetUnitCountingFake extends Fleet
+{
+    public array $driverRelations  = [];
+    public array $vehicleRelations = [];
+
+    public function drivers()
+    {
+        $relation                = new FleetOpsFleetUnitCountingRelationFake(5);
+        $this->driverRelations[] = $relation;
+
+        return $relation;
+    }
+
+    public function vehicles()
+    {
+        $relation                 = new FleetOpsFleetUnitCountingRelationFake(8);
+        $this->vehicleRelations[] = $relation;
+
+        return $relation;
+    }
+}
+
+class FleetOpsFleetUnitSavingFake extends Fleet
+{
+    public bool $saved = false;
+
+    public function save(array $options = []): bool
+    {
+        $this->saved = true;
+
+        return true;
+    }
+}
+
+function fleetopsFleetUnitUseRelationConnection(): void
+{
+    $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
+    $resolver   = new ConnectionResolver([
+        'default' => $connection,
+        'mysql'   => $connection,
+    ]);
+
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+}
+
+test('fleet exposes relation contracts activity options and slug options', function () {
+    fleetopsFleetUnitUseRelationConnection();
+
+    $fleet = new Fleet();
+    $fleet->setRawAttributes(['uuid' => 'fleet-uuid', 'name' => 'Night Fleet'], true);
+
+    expect($fleet->photo())->toBeInstanceOf(BelongsTo::class)
+        ->and($fleet->serviceArea())->toBeInstanceOf(BelongsTo::class)
+        ->and($fleet->zone())->toBeInstanceOf(BelongsTo::class)
+        ->and($fleet->vendor())->toBeInstanceOf(BelongsTo::class)
+        ->and($fleet->parentFleet())->toBeInstanceOf(BelongsTo::class)
+        ->and($fleet->subFleets())->toBeInstanceOf(HasMany::class)
+        ->and($fleet->drivers())->toBeInstanceOf(HasManyThrough::class)
+        ->and($fleet->vehicles())->toBeInstanceOf(HasManyThrough::class)
+        ->and($fleet->getActivitylogOptions())->toBeInstanceOf(LogOptions::class)
+        ->and($fleet->getSlugOptions())->toBeInstanceOf(SlugOptions::class);
+});
+
+test('fleet accessors count assigned drivers and vehicles', function () {
+    $fleet = new FleetOpsFleetUnitCountingFake();
+    $fleet->setRawAttributes(['uuid' => 'fleet-uuid'], true);
+
+    expect($fleet->getPhotoUrlAttribute())->toBe('https://s3.ap-northeast-2.amazonaws.com/fleetbase/public/default-fleet.png')
+        ->and($fleet->getDriversCountAttribute())->toBe(5)
+        ->and($fleet->getDriversOnlineCountAttribute())->toBe(5)
+        ->and($fleet->driverRelations[1]->wheres)->toBe([['online', 1]])
+        ->and($fleet->getVehiclesCountAttribute())->toBe(8)
+        ->and($fleet->getVehiclesOnlineCountAttribute())->toBe(8)
+        ->and($fleet->vehicleRelations[1]->wheres)->toBe([['online', 1]]);
+});
+
+test('fleet import resolves supported name columns and optional persistence', function () {
+    session(['company' => 'company-fleet-unit']);
+
+    $unsaved = FleetOpsFleetUnitSavingFake::createFromImport([
+        'fleet_name' => 'Harbor Fleet',
+        'empty'      => null,
+    ]);
+
+    $saved = FleetOpsFleetUnitSavingFake::createFromImport([
+        'fleet' => 'Airport Fleet',
+    ], true);
+
+    expect($unsaved)->toBeInstanceOf(FleetOpsFleetUnitSavingFake::class)
+        ->and($unsaved->company_uuid)->toBe('company-fleet-unit')
+        ->and($unsaved->name)->toBe('Harbor Fleet')
+        ->and($unsaved->status)->toBe('active')
+        ->and($unsaved->saved)->toBeFalse()
+        ->and($saved->name)->toBe('Airport Fleet')
+        ->and($saved->saved)->toBeTrue();
+});

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

@@ -0,0 +1,82 @@
+<?php
+
+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 $key === "fleetbase.connection.db" ? "mysql" : $default; }');
+}
+
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\FuelProviderConnection;
+use Fleetbase\FleetOps\Models\FuelProviderTransaction;
+use Fleetbase\FleetOps\Models\FuelReport;
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\LaravelMysqlSpatial\Types\Point;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\SQLiteConnection;
+
+function fleetopsFuelProviderTransactionUseRelationConnection(): void
+{
+    $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
+    $resolver   = new ConnectionResolver([
+        'default' => $connection,
+        'mysql'   => $connection,
+    ]);
+
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+}
+
+test('fuel provider transaction relationship contracts resolve expected models', function () {
+    fleetopsFuelProviderTransactionUseRelationConnection();
+
+    $transaction = new FuelProviderTransaction();
+
+    expect($transaction->connection())->toBeInstanceOf(BelongsTo::class)
+        ->and($transaction->connection()->getRelated())->toBeInstanceOf(FuelProviderConnection::class)
+        ->and($transaction->fuelReport())->toBeInstanceOf(BelongsTo::class)
+        ->and($transaction->fuelReport()->getRelated())->toBeInstanceOf(FuelReport::class)
+        ->and($transaction->vehicle())->toBeInstanceOf(BelongsTo::class)
+        ->and($transaction->vehicle()->getRelated())->toBeInstanceOf(Vehicle::class)
+        ->and($transaction->driver())->toBeInstanceOf(BelongsTo::class)
+        ->and($transaction->driver()->getRelated())->toBeInstanceOf(Driver::class)
+        ->and($transaction->order())->toBeInstanceOf(BelongsTo::class)
+        ->and($transaction->order()->getRelated())->toBeInstanceOf(Order::class);
+});
+
+test('fuel provider transaction exposes related display attributes and station point', function () {
+    $vehicle = new Vehicle();
+    $vehicle->setRawAttributes(['name' => 'Truck 42'], true);
+
+    $driver = new Driver();
+    $driver->setRelation('user', (object) ['name' => 'Jane Driver']);
+
+    $fuelReport = new FuelReport();
+    $fuelReport->setRawAttributes(['public_id' => 'fuel_report_001'], true);
+
+    $transaction = new FuelProviderTransaction([
+        'station_latitude'  => 1.3521,
+        'station_longitude' => 103.8198,
+    ]);
+    $transaction->setRelation('vehicle', $vehicle);
+    $transaction->setRelation('driver', $driver);
+    $transaction->setRelation('fuelReport', $fuelReport);
+
+    expect($transaction->vehicle_name)->toBe('Truck 42')
+        ->and($transaction->driver_name)->toBe('Jane Driver')
+        ->and($transaction->fuel_report_id)->toBe('fuel_report_001')
+        ->and($transaction->station_location)->toBeInstanceOf(Point::class)
+        ->and($transaction->station_location->getLat())->toBe(1.3521)
+        ->and($transaction->station_location->getLng())->toBe(103.8198);
+});
+
+test('fuel provider transaction returns null station locations for incomplete coordinates', function () {
+    expect((new FuelProviderTransaction())->station_location)->toBeNull()
+        ->and((new FuelProviderTransaction(['station_latitude' => 1.3521]))->station_location)->toBeNull()
+        ->and((new FuelProviderTransaction(['station_longitude' => 103.8198]))->station_location)->toBeNull();
+});

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

@@ -0,0 +1,193 @@
+<?php
+
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\Entity;
+use Fleetbase\FleetOps\Models\FuelReport;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\Relations;
+use Illuminate\Database\SQLiteConnection;
+
+/**
+ * Covers the FuelReport relation builders and import resolution (reporter,
+ * driver, vehicle and location fallbacks), and the Entity label and pdf
+ * rendering paths.
+ */
+if (!class_exists('FleetOpsWaypointViewRecorder', false)) {
+    class FleetOpsWaypointViewRecorder
+    {
+        public static array $views = [];
+    }
+}
+
+if (!function_exists('Fleetbase\FleetOps\Models\view')) {
+    eval('namespace Fleetbase\FleetOps\Models; function view($name = null, $data = []) { \FleetOpsWaypointViewRecorder::$views[] = [$name, array_keys($data)]; return new class { public function render() { return "<html>waypoint-label</html>"; } }; }');
+}
+
+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); }');
+}
+
+function fleetopsFuelReportBoot(): SQLiteConnection
+{
+    $pdo = new PDO('sqlite::memory:');
+    foreach (['ST_PointFromText', 'ST_GeomFromText'] as $fn) {
+        $pdo->sqliteCreateFunction($fn, fn ($wkt, $srid = 0, $axisOrder = null) => $wkt);
+    }
+    $pdo->sqliteCreateFunction('CONCAT', fn (...$parts) => implode('', array_map(strval(...), $parts)));
+    $connection = new SQLiteConnection($pdo);
+    $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);
+        }
+    });
+    Illuminate\Support\Facades\DB::clearResolvedInstance('db');
+
+    $schema = $connection->getSchemaBuilder();
+    $tables = [
+        'fuel_reports'     => ['uuid', 'public_id', 'company_uuid', 'reported_by_uuid', 'driver_uuid', 'vehicle_uuid', 'report', 'odometer', 'amount', 'currency', 'volume', 'metric_unit', 'status', 'location', 'meta', '_key'],
+        'users'            => ['uuid', 'public_id', 'company_uuid', 'name', 'email', 'type', 'status', '_key'],
+        'drivers'          => ['uuid', 'public_id', 'company_uuid', 'user_uuid', 'drivers_license_number', 'status', '_key'],
+        'vehicles'         => ['uuid', 'public_id', 'company_uuid', 'plate_number', 'make', 'model', 'year', 'display_name', '_key'],
+        'entities'         => ['uuid', 'public_id', 'company_uuid', 'payload_uuid', 'destination_uuid', 'tracking_number_uuid', 'name', 'type', 'meta', '_key'],
+        'places'           => ['uuid', 'public_id', 'company_uuid', 'name', 'location', '_key'],
+        'tracking_numbers' => ['uuid', 'public_id', 'company_uuid', 'tracking_number', '_key'],
+        'companies'        => ['uuid', 'public_id', 'name', 'country'],
+        'issues'           => ['uuid', 'public_id', 'company_uuid', 'reported_by_uuid', 'assigned_to_uuuid', 'driver_uuid', 'vehicle_uuid', 'priority', 'report', 'category', 'type', 'location', 'status', 'meta', 'slug', 'internal_id', '_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']);
+    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());
+
+    return $connection;
+}
+
+test('fuel report relations and imports resolve reporters drivers and vehicles', function () {
+    $connection = fleetopsFuelReportBoot();
+    $connection->table('users')->insert(['uuid' => 'user-fuel-1', 'company_uuid' => 'company-1', 'name' => 'Fuel Reporter']);
+    $connection->table('drivers')->insert(['uuid' => 'driver-fuel-1', 'public_id' => 'driver_fuelimport', 'company_uuid' => 'company-1', 'user_uuid' => 'user-fuel-1']);
+    $connection->table('vehicles')->insert(['uuid' => 'vehicle-fuel-1', 'public_id' => 'vehicle_fuelimport', 'company_uuid' => 'company-1', 'plate_number' => 'SGX-9911', 'make' => 'Volvo', 'model' => 'FH16', 'display_name' => 'Volvo FH16']);
+
+    // Relation builders expose the expected foreign keys
+    $fuelReport = new FuelReport();
+    expect($fuelReport->driver())->toBeInstanceOf(Illuminate\Database\Eloquent\Relations\BelongsTo::class)
+        ->and($fuelReport->vehicle())->toBeInstanceOf(Illuminate\Database\Eloquent\Relations\BelongsTo::class)
+        ->and($fuelReport->reportedBy())->toBeInstanceOf(Illuminate\Database\Eloquent\Relations\BelongsTo::class)
+        ->and($fuelReport->reporter())->toBeInstanceOf(Illuminate\Database\Eloquent\Relations\BelongsTo::class)
+        ->and($fuelReport->reporter()->getForeignKeyName())->toBe('reported_by_uuid');
+
+    // Imports resolve names into relations and fall back to array locations
+    $imported = FuelReport::createFromImport([
+        'reporter' => 'Fuel Reporter',
+        'driver'   => 'driver_fuelimport',
+        'vehicle'  => 'Volvo FH16',
+        'report'   => 'Topped up before route',
+        'amount'   => '85.50',
+        'currency' => 'SGD',
+        'volume'   => '60',
+        'location' => ['latitude' => 1.31, 'longitude' => 103.82],
+    ], true);
+
+    expect($imported)->toBeInstanceOf(FuelReport::class)
+        ->and($imported->reported_by_uuid)->toBe('user-fuel-1')
+        ->and($imported->driver_uuid)->toBe('driver-fuel-1')
+        ->and($imported->vehicle_uuid)->toBe('vehicle-fuel-1')
+        ->and($connection->table('fuel_reports')->count())->toBe(1);
+});
+
+test('entity labels render views and stream pdf output', function () {
+    $connection = fleetopsFuelReportBoot();
+    $connection->table('entities')->insert(['uuid' => 'entity-label-1', 'company_uuid' => 'company-1', 'destination_uuid' => 'place-el-1', 'tracking_number_uuid' => 'tn-el-1', 'name' => 'Labeled Goods']);
+    $connection->table('places')->insert(['uuid' => 'place-el-1', 'company_uuid' => 'company-1', 'name' => 'Entity Dest']);
+    $connection->table('tracking_numbers')->insert(['uuid' => 'tn-el-1', 'company_uuid' => 'company-1', 'tracking_number' => 'FLB-ENT-1']);
+    $connection->table('companies')->insert(['uuid' => 'company-1', 'name' => 'Entity Co']);
+
+    $entity = Entity::where('uuid', 'entity-label-1')->first();
+
+    FleetOpsWaypointViewRecorder::$views = [];
+    expect($entity->label())->toContain('<html>')
+        ->and(FleetOpsWaypointViewRecorder::$views[0][0])->toContain('label');
+
+    $wrapper = new class {
+        public function loadHTML(string $html, ?string $encoding = null): self
+        {
+            return $this;
+        }
+
+        public function stream()
+        {
+            return 'entity-pdf-stream';
+        }
+
+        public function __call($method, $arguments)
+        {
+            return $this;
+        }
+    };
+    Illuminate\Container\Container::getInstance()->instance('dompdf.wrapper', $wrapper);
+    app()->instance('dompdf.wrapper', $wrapper);
+
+    expect($entity->pdfLabel())->toBe($wrapper)
+        ->and($entity->pdfLabelStream())->toBe('entity-pdf-stream');
+});
+
+test('issue imports resolve drivers vehicles and locations', function () {
+    $connection = fleetopsFuelReportBoot();
+    session(['company' => 'company-1', 'user' => 'company-1']);
+    $connection->table('users')->insert(['uuid' => 'user-issue-1', 'company_uuid' => 'company-1', 'name' => 'Issue Reporter']);
+    $connection->table('drivers')->insert(['uuid' => 'driver-issue-1', 'public_id' => 'driver_issueimport', 'company_uuid' => 'company-1', 'user_uuid' => 'user-issue-1']);
+    $connection->table('vehicles')->insert(['uuid' => 'vehicle-issue-1', 'public_id' => 'vehicle_issueimport', 'company_uuid' => 'company-1', 'plate_number' => 'SGZ-1122', 'make' => 'Scania', 'model' => 'R500', 'display_name' => 'Scania R500']);
+
+    $imported = Fleetbase\FleetOps\Models\Issue::createFromImport([
+        'priority' => 'high',
+        'report'   => 'Engine overheating on route',
+        'reporter' => 'Issue Reporter',
+        'assignee' => 'Issue Reporter',
+        'category' => 'mechanical',
+        'type'     => 'vehicle',
+        'driver'   => 'driver_issueimport',
+        'vehicle'  => 'Scania R500',
+        'location' => ['latitude' => 1.33, 'longitude' => 103.85],
+    ], true);
+
+    expect($imported)->toBeInstanceOf(Fleetbase\FleetOps\Models\Issue::class)
+        ->and($imported->reported_by_uuid)->toBe('user-issue-1')
+        ->and($imported->driver_uuid)->toBe('driver-issue-1')
+        ->and($imported->vehicle_uuid)->toBe('vehicle-issue-1')
+        ->and($connection->table('issues')->count())->toBe(1);
+});

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

@@ -0,0 +1,100 @@
+<?php
+
+use Fleetbase\FleetOps\Models\Issue;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Models\Zone;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+/**
+ * Covers the fallbacks the CSV importers take on rows that omit the columns
+ * every fixture supplies, plus the zone centroid fallback for a border that
+ * never became a polygon.
+ */
+// The vehicle-name parser reads its make/model dataset relative to the
+// installed package path, which does not exist when running in-tree.
+if (!function_exists('Fleetbase\FleetOps\Support\base_path')) {
+    eval('namespace Fleetbase\FleetOps\Support; function base_path($path = "") { return getcwd() . "/" . str_replace("vendor/fleetbase/fleetops-api/", "", $path); }');
+}
+
+function fleetopsImportSeamBoot(): 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();
+    $columns = ['uuid', 'public_id', 'company_uuid', 'user_uuid', 'driver_uuid', 'vehicle_uuid', 'name', 'type', 'status', 'make', 'model', 'year', '_key'];
+    foreach (['users', 'drivers', 'vehicles', 'issues'] as $table) {
+        $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-import-1']);
+
+    return $connection;
+}
+
+test('vehicle imports fall back to the raw name when nothing parses out of it', function () {
+    fleetopsImportSeamBoot();
+
+    // A name the vehicle-data parser cannot decompose leaves make unset, and
+    // dropping the row's only identifying value would lose the vehicle.
+    $vehicle = Vehicle::createFromImport(['vehicle' => 'Zzqx Unparseable 9000']);
+
+    expect($vehicle->make)->toBe('Zzqx Unparseable 9000');
+});
+
+test('issue imports without any location column resolve to no point', function () {
+    fleetopsImportSeamBoot();
+
+    $issue = Issue::createFromImport(['issue' => 'Cracked windscreen', 'type' => 'vehicle']);
+
+    expect($issue)->toBeInstanceOf(Issue::class);
+});
+
+test('zone centroids fall back to null island when the border is not a polygon', function () {
+    fleetopsImportSeamBoot();
+
+    // The engine is resolved before the border is inspected, so it has to be
+    // present even on the path that never asks it for a centroid.
+    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);
+        }
+    });
+
+    $zone = new Zone();
+    $zone->setRawAttributes(['uuid' => 'zone-import-1', 'name' => 'Borderless', 'border' => null], true);
+
+    $centroid = $zone->getCentroid();
+
+    expect($centroid)->toBeInstanceOf(Brick\Geo\Point::class)
+        ->and($centroid->x())->toBe(0.0)
+        ->and($centroid->y())->toBe(0.0);
+});