@fleetbase/fleetops-engine 0.6.58 → 0.6.59

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

@@ -0,0 +1,384 @@
+<?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\FleetOps\Support\env')) {
+    eval('namespace Fleetbase\FleetOps\Support; function env($key = null, $default = null) { return $default; }');
+}
+
+if (!function_exists('Fleetbase\FleetOps\Models\env')) {
+    eval('namespace Fleetbase\FleetOps\Models; function env($key = null, $default = null) { return $default; }');
+}
+
+if (!function_exists('Fleetbase\Models\asset')) {
+    eval('namespace Fleetbase\Models; function asset($path = null, $secure = null) { return "https://assets.example.com/" . ltrim((string) $path, "/"); }');
+}
+
+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; } }; }');
+}
+
+use Fleetbase\FleetOps\Models\Place;
+use Fleetbase\LaravelMysqlSpatial\Types\Point;
+use Illuminate\Contracts\Filesystem\Filesystem;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+/**
+ * Covers Place avatar resolution by file uuid, reverse-geocoding creation
+ * fallbacks with an empty geocoder, coordinate-based creation and insertion,
+ * mixed-input uuid and public-id resolution, shared-place matching guards,
+ * geocoding query composition, and import-row creation for single-address
+ * and multi-column rows against SQLite.
+ */
+function fleetopsPlaceCreationBoot(): 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);
+    $pdo->sqliteCreateFunction('ST_Equals', fn ($a, $b) => (string) $a === (string) $b ? 1 : 0);
+    $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');
+
+    $disk = new class implements Filesystem {
+        public function url($path)
+        {
+            return 'https://cdn.example.com/' . ltrim((string) $path, '/');
+        }
+
+        public function exists($path)
+        {
+            return true;
+        }
+
+        public function get($path)
+        {
+            return '';
+        }
+
+        public function readStream($path)
+        {
+            return null;
+        }
+
+        public function put($path, $contents, $options = [])
+        {
+            return true;
+        }
+
+        public function writeStream($path, $resource, array $options = [])
+        {
+            return true;
+        }
+
+        public function getVisibility($path)
+        {
+            return 'public';
+        }
+
+        public function setVisibility($path, $visibility)
+        {
+            return true;
+        }
+
+        public function prepend($path, $data)
+        {
+            return true;
+        }
+
+        public function append($path, $data)
+        {
+            return true;
+        }
+
+        public function delete($paths)
+        {
+            return true;
+        }
+
+        public function copy($from, $to)
+        {
+            return true;
+        }
+
+        public function move($from, $to)
+        {
+            return true;
+        }
+
+        public function size($path)
+        {
+            return 0;
+        }
+
+        public function lastModified($path)
+        {
+            return 0;
+        }
+
+        public function files($directory = null, $recursive = false)
+        {
+            return [];
+        }
+
+        public function allFiles($directory = null)
+        {
+            return [];
+        }
+
+        public function directories($directory = null, $recursive = false)
+        {
+            return [];
+        }
+
+        public function allDirectories($directory = null)
+        {
+            return [];
+        }
+
+        public function makeDirectory($path)
+        {
+            return true;
+        }
+
+        public function deleteDirectory($directory)
+        {
+            return true;
+        }
+    };
+    app()->instance('filesystem', new class($disk) {
+        public function __construct(public $d)
+        {
+        }
+
+        public function disk($disk = null)
+        {
+            return $this->d;
+        }
+
+        public function __call($method, $arguments)
+        {
+            return $this->d->{$method}(...$arguments);
+        }
+    });
+    Illuminate\Support\Facades\Storage::clearResolvedInstance('filesystem');
+
+    app()->forgetInstance('fleetops.geocoder');
+    app()->instance('geocoder', new class {
+        public function geocode($query)
+        {
+            return $this;
+        }
+
+        public function reverse($lat, $lng)
+        {
+            return $this;
+        }
+
+        public function get()
+        {
+            return collect();
+        }
+
+        public function __call($method, $arguments)
+        {
+            return $this;
+        }
+    });
+
+    $schema = $connection->getSchemaBuilder();
+    $tables = [
+        'places'    => ['uuid', 'public_id', 'company_uuid', 'owner_uuid', 'owner_type', 'name', 'street1', 'street2', 'city', 'province', 'postal_code', 'country', 'neighborhood', 'building', 'phone', 'location', 'meta', 'type', 'avatar_url', '_key', '_import_id'],
+        'files'     => ['uuid', 'public_id', 'company_uuid', 'name', 'original_filename', 'extension', 'content_type', 'path', 'bucket', 'disk', 'size', 'type', 'meta', '_key'],
+        'companies' => ['uuid', 'public_id', 'name', 'country'],
+    ];
+    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', 'api_key' => 'console']);
+    $connection->table('companies')->insert(['uuid' => 'company-1', 'name' => 'Acme', 'country' => 'SG']);
+
+    return $connection;
+}
+
+test('avatar urls resolve file uuids keys and passthrough values', function () {
+    $connection = fleetopsPlaceCreationBoot();
+
+    $place = new Place();
+    $place->setRawAttributes(['avatar_url' => 'https://cdn.example.com/avatar.png'], true);
+    expect($place->avatar_url)->toBe('https://cdn.example.com/avatar.png');
+
+    // Uuid-shaped avatar values resolve through the file lookup, which
+    // yields null when no such file exists
+    $byUuid = new Place();
+    $byUuid->setRawAttributes(['avatar_url' => '99999999-9999-4999-8999-999999999999'], true);
+    expect($byUuid->avatar_url)->toBeNull()
+        ->and(Place::getAvatar('88888888-8888-4888-8888-888888888888'))->toBeNull();
+
+    // A stored file on a non-local disk hands back its url directly
+    $connection->table('files')->insert([
+        'uuid'         => '77777777-7777-4777-8777-777777777777',
+        'public_id'    => 'file_placeavatar',
+        'company_uuid' => 'company-1',
+        'disk'         => 'public',
+        'path'         => 'uploads/place-avatar.png',
+    ]);
+
+    expect(Place::getAvatar('77777777-7777-4777-8777-777777777777'))
+        ->toBe('https://cdn.example.com/uploads/place-avatar.png');
+});
+
+test('reverse geocoding creation falls back to bare locations', function () {
+    $connection = fleetopsPlaceCreationBoot();
+
+    $fromCoords = Place::createFromCoordinates([1.35, 103.85], ['name' => 'Coord Stop'], true);
+    expect($fromCoords)->toBeInstanceOf(Place::class)
+        ->and($connection->table('places')->where('name', 'Coord Stop')->count())->toBe(1);
+
+    // Without reverse-geocoding results there is no address to build the place
+    // from, so the insert reports failure. It must not fall through: the empty
+    // address array carries location 0,0 and would overwrite the real point.
+    expect(Place::insertFromCoordinates(new Point(1.40, 103.90), ['name' => 'Inserted Stop']))->toBeFalse()
+        ->and($connection->table('places')->where('name', 'Inserted Stop')->count())->toBe(0);
+});
+
+test('mixed input resolution matches uuids public ids and coordinates', function () {
+    $connection = fleetopsPlaceCreationBoot();
+    $connection->table('places')->insert(['uuid' => '11111111-1111-4111-8111-111111111111', 'public_id' => 'place_mixres1', 'company_uuid' => 'company-1', 'name' => 'Depot', 'street1' => 'Main St']);
+
+    expect(Place::insertFromMixed('place_mixres1'))->toBe('11111111-1111-4111-8111-111111111111')
+        ->and(Place::insertFromMixed('11111111-1111-4111-8111-111111111111'))->toBe('11111111-1111-4111-8111-111111111111');
+
+    $fromCoordArray = Place::createFromMixed([1.32, 103.82], [], true);
+    expect($fromCoordArray)->toBeInstanceOf(Place::class);
+
+    expect(Place::composeGeocodingQuery(['street1' => 'Main St', 'city' => 'Singapore', 'country' => 'SG']))->toBe('Main St, Singapore, SG')
+        ->and(Place::composeGeocodingQuery(['street1' => '  ']))->toBeNull();
+});
+
+test('shared place matching parses locations and guards unresolvable ones', function () {
+    $connection = fleetopsPlaceCreationBoot();
+    $connection->table('places')->insert([
+        'uuid'    => '22222222-2222-4222-8222-222222222222', 'company_uuid' => 'company-1',
+        'street1' => 'Shared St', 'city' => 'Singapore', 'country' => 'SG', 'postal_code' => null, 'owner_uuid' => null,
+    ]);
+
+    $existing = Place::findExistingSharedPlace([
+        'street1'  => 'Shared St',
+        'city'     => 'Singapore',
+        'country'  => 'SG',
+        'location' => ['lat' => 1.3, 'lng' => 103.8],
+    ]);
+    expect($existing?->uuid)->toBe('22222222-2222-4222-8222-222222222222');
+
+    // An unresolvable location value falls back to the guard once no
+    // exact row matches
+    $guarded = Place::findExistingSharedPlace([
+        'street1'  => 'Unknown St',
+        'city'     => 'Singapore',
+        'country'  => 'SG',
+        'location' => 'not-resolvable-location',
+    ]);
+    expect($guarded)->toBeNull();
+
+    // Owner-scoped places never match shared records
+    expect(Place::findExistingSharedPlace(['owner_uuid' => 'contact-1']))->toBeNull();
+});
+
+test('import rows create places for address only and multi column rows', function () {
+    $connection = fleetopsPlaceCreationBoot();
+
+    $single = Place::createFromImportRow(['address' => '88 Somewhere Road']);
+    expect($single)->toBeInstanceOf(Place::class)
+        ->and($single->street1)->toBe('88 Somewhere Road');
+
+    $multi = Place::createFromImportRow([
+        'name'    => 'Warehouse 5',
+        'street1' => 'Industrial Ave 5',
+        'city'    => 'Singapore',
+        'notes'   => 'roll-up door',
+    ], 'import-1');
+    expect($multi)->toBeInstanceOf(Place::class)
+        ->and($multi->location)->not->toBeNull();
+});
+
+test('mixed insertion routes an address key through the geocoding lookup', function () {
+    $connection = fleetopsPlaceCreationBoot();
+
+    // Neither a uuid nor a public id, so the array falls through to the address
+    // branch; the geocoder returns nothing, so the address stands in as street1
+    $uuid = Place::insertFromMixed(['address' => '404 Nowhere Boulevard']);
+
+    expect($uuid)->toBeString()
+        ->and($connection->table('places')->where('uuid', $uuid)->value('street1'))->toBe('404 Nowhere Boulevard');
+});
+
+test('single column imports fall back to mixed creation when geocoding is empty', function () {
+    fleetopsPlaceCreationBoot();
+
+    // An injected geocoder returns no addresses instead of rejecting the
+    // request, so the import reaches the post-lookup fallback rather than the
+    // catch arm above it
+    app()->instance('fleetops.geocoder', new class {
+        public function geocodeQuery($query)
+        {
+            return new Geocoder\Model\AddressCollection([]);
+        }
+
+        public function reverseQuery($query)
+        {
+            return new Geocoder\Model\AddressCollection([]);
+        }
+    });
+
+    $place = Place::createFromImport(['address' => '77 Unmatched Way'], false);
+
+    expect($place)->toBeInstanceOf(Place::class)
+        ->and($place->street1)->toBe('77 Unmatched Way');
+});
+
+test('single column imports reverse lookups and coordinate arrays create places', function () {
+    $connection = fleetopsPlaceCreationBoot();
+
+    // Single-column import rows resolve through geocoding then mixed fallback
+    $imported = Place::createFromImport(['address' => '88 Single Column'], true);
+    expect($imported)->toBeInstanceOf(Place::class);
+
+    // Reverse lookups surface the keyless geocoder rejection pre-network
+    expect(fn () => Place::createFromReverseGeocodingLookup(new Point(1.36, 103.86), true))
+        ->toThrow(Exception::class);
+
+    // Array coordinates resolve through the mixed point branch, then report
+    // failure because the geocoder returns no address to build the place from
+    expect(Place::insertFromCoordinates([1.42, 103.92], ['name' => 'Array Inserted Stop']))->toBeFalse()
+        ->and($connection->table('places')->where('name', 'Array Inserted Stop')->count())->toBe(0);
+});

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

@@ -0,0 +1,253 @@
+<?php
+
+use Fleetbase\FleetOps\Models\Place;
+use Fleetbase\LaravelMysqlSpatial\Types\Point as SpatialPoint;
+use Geocoder\Model\AddressCollection;
+use Geocoder\Provider\GoogleMaps\Model\GoogleAddress;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+/**
+ * Covers how places are built from geocoding results: a hit is mapped through
+ * the Google address translation, while an empty reverse lookup falls back to
+ * a bare place carrying only the requested point.
+ */
+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 fleetopsPlaceGeocodeBoot(array $results): SQLiteConnection
+{
+    $pdo = new PDO('sqlite::memory:');
+    foreach (['ST_PointFromText', 'ST_GeomFromText'] as $spatialFunction) {
+        $pdo->sqliteCreateFunction($spatialFunction, fn ($wkt, $srid = 0, $axisOrder = null) => $wkt);
+    }
+    // The shared-place lookup compares locations spatially; string equality is
+    // enough here because both sides are the same passthrough WKT
+    $pdo->sqliteCreateFunction('ST_Equals', fn ($left, $right) => (int) ((string) $left === (string) $right));
+    $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');
+
+    $connection->getSchemaBuilder()->create('places', function ($blueprint) {
+        $blueprint->increments('id');
+        foreach (['uuid', 'public_id', 'company_uuid', 'owner_uuid', 'owner_type', 'name', 'street1', 'street2', 'building', 'neighborhood', 'district', 'city', 'province', 'postal_code', 'country', 'phone', 'type', 'location', 'meta', '_key'] as $column) {
+            $blueprint->string($column)->nullable();
+        }
+        $blueprint->timestamps();
+        $blueprint->timestamp('deleted_at')->nullable();
+    });
+
+    $geocoder = new class($results) {
+        public function __construct(private array $results)
+        {
+        }
+
+        public function geocode($address)
+        {
+            return $this;
+        }
+
+        public function reverse($latitude, $longitude)
+        {
+            return $this;
+        }
+
+        public function geocodeQuery($query)
+        {
+            return new AddressCollection($this->results);
+        }
+
+        public function reverseQuery($query)
+        {
+            return new AddressCollection($this->results);
+        }
+
+        public function get()
+        {
+            return collect($this->results);
+        }
+    };
+
+    app()->instance('redis', new class {
+        public function connection(): self
+        {
+            return $this;
+        }
+
+        public function __call(string $method, array $arguments): mixed
+        {
+            return null;
+        }
+    });
+
+    app()->instance('geocoder', $geocoder);
+    app()->instance('fleetops.geocoder', $geocoder);
+    Geocoder\Laravel\Facades\Geocoder::clearResolvedInstances();
+
+    session(['company' => 'company-geo-1']);
+
+    return $connection;
+}
+
+test('geocoding lookups map hits and fall back to the raw address', function () {
+    $address = GoogleAddress::createFromArray([
+        'streetNumber' => '1',
+        'streetName'   => 'Marina Boulevard',
+        'locality'     => 'Singapore',
+        'postalCode'   => '018989',
+        'country'      => 'Singapore',
+        'countryCode'  => 'SG',
+        'latitude'     => 1.2816,
+        'longitude'    => 103.8636,
+    ]);
+
+    // A geocoding hit is translated into place attributes
+    fleetopsPlaceGeocodeBoot([$address]);
+    $values = Place::getValuesFromGeocodingLookup('1 Marina Boulevard');
+    expect($values)->toBeArray()
+        ->and($values['city'] ?? null)->toBe('Singapore')
+        ->and($values['postal_code'] ?? null)->toBe('018989')
+        ->and($values['country'] ?? null)->toBe('SG');
+
+    // With no results the raw query is kept as the street and the point is empty
+    fleetopsPlaceGeocodeBoot([]);
+    $fallback = Place::getValuesFromGeocodingLookup('Nowhere Road');
+    expect($fallback['street1'])->toBe('Nowhere Road')
+        ->and($fallback['location'])->toBeInstanceOf(SpatialPoint::class);
+});
+
+test('reverse geocoding with no results yields a place holding just the point', function () {
+    fleetopsPlaceGeocodeBoot([]);
+
+    $point = new SpatialPoint(1.30, 103.80);
+    $place = Place::createFromReverseGeocodingLookup($point);
+
+    expect($place)->toBeInstanceOf(Place::class)
+        ->and($place->location)->not->toBeNull();
+});
+
+test('inserting from coordinates persists the reverse geocoded address', function () {
+    $address = GoogleAddress::createFromArray([
+        'streetNumber' => '10',
+        'streetName'   => 'Bayfront Avenue',
+        'locality'     => 'Singapore',
+        'postalCode'   => '018956',
+        'country'      => 'Singapore',
+        'countryCode'  => 'SG',
+        'latitude'     => 1.2834,
+        'longitude'    => 103.8607,
+    ]);
+
+    $connection = fleetopsPlaceGeocodeBoot([$address]);
+    $uuid       = Place::insertFromCoordinates([1.2834, 103.8607]);
+
+    expect($uuid)->toBeString();
+    $row = $connection->table('places')->where('uuid', $uuid)->first();
+    expect($row->city)->toBe('Singapore')
+        ->and($row->postal_code)->toBe('018956')
+        ->and($row->street1)->toBe('10 Bayfront Avenue');
+
+    // No reverse geocoding result means nothing is inserted
+    fleetopsPlaceGeocodeBoot([]);
+    expect(Place::insertFromCoordinates([1.2834, 103.8607]))->toBeFalse();
+});
+
+test('inserting from a mixed address string geocodes and persists', function () {
+    $address = GoogleAddress::createFromArray([
+        'streetNumber' => '2',
+        'streetName'   => 'Orchard Turn',
+        'locality'     => 'Singapore',
+        'postalCode'   => '238801',
+        'country'      => 'Singapore',
+        'countryCode'  => 'SG',
+        'latitude'     => 1.3040,
+        'longitude'    => 103.8318,
+    ]);
+
+    $connection = fleetopsPlaceGeocodeBoot([$address]);
+    $uuid       = Place::insertFromMixed('2 Orchard Turn Singapore');
+
+    expect($uuid)->toBeString();
+    expect($connection->table('places')->where('uuid', $uuid)->value('postal_code'))->toBe('238801');
+});
+
+test('inserting from a google address routes through the google address handler', function () {
+    $address = GoogleAddress::createFromArray([
+        'streetNumber' => '12',
+        'streetName'   => 'Marina View',
+        'locality'     => 'Singapore',
+        'postalCode'   => '018961',
+        'country'      => 'Singapore',
+        'countryCode'  => 'SG',
+        'latitude'     => 1.2795,
+        'longitude'    => 103.8543,
+    ]);
+
+    $connection = fleetopsPlaceGeocodeBoot([]);
+
+    // A GoogleAddress is an object, so it must be matched before the generic
+    // array/object arm — otherwise it gets flattened to an array and loses the
+    // address translation entirely
+    $uuid = Place::insertFromMixed($address);
+
+    expect($uuid)->toBeString();
+    $row = $connection->table('places')->where('uuid', $uuid)->first();
+    expect($row->city)->toBe('Singapore')
+        ->and($row->postal_code)->toBe('018961')
+        ->and($row->street1)->toBe('12 Marina View');
+});
+
+test('shared place lookups bail out when the location cannot be resolved', function () {
+    fleetopsPlaceGeocodeBoot([]);
+
+    // An unresolvable place public id makes Utils::getPointFromMixed() return
+    // null, so there is no point to match a shared place on
+    $resolved = Place::findExistingSharedPlace([
+        'company_uuid' => 'company-geo-1',
+        'street1'      => '1 Nonexistent Way',
+        'city'         => 'Singapore',
+        'country'      => 'SG',
+        'location'     => 'place_doesnotexist',
+    ]);
+
+    expect($resolved)->toBeNull();
+});
+
+test('import rows resolving to a coordinateless address fall back to the null island', function () {
+    // A geocoding hit carrying no coordinates leaves the place without a
+    // location, and the row supplies no latitude/longitude columns either
+    $address = GoogleAddress::createFromArray([
+        'streetNumber' => '5',
+        'streetName'   => 'Raffles Place',
+        'locality'     => 'Singapore',
+        'country'      => 'Singapore',
+        'countryCode'  => 'SG',
+    ]);
+
+    fleetopsPlaceGeocodeBoot([$address]);
+    $place = Place::createFromImportRow(['street' => '5 Raffles Place', 'town' => 'Singapore']);
+
+    expect($place)->toBeInstanceOf(Place::class)
+        ->and($place->location)->toBeInstanceOf(SpatialPoint::class)
+        ->and($place->location->getLat())->toBe(0.0)
+        ->and($place->location->getLng())->toBe(0.0);
+});