@fleetbase/fleetops-engine 0.6.58 → 0.6.59

package/server/tests/TrackingNumberTraitContractsTest.php

@@ -0,0 +1,106 @@
+<?php
+
+use Fleetbase\FleetOps\Models\Proof;
+use Fleetbase\FleetOps\Models\TrackingNumber;
+use Fleetbase\FleetOps\Traits\HasTrackingNumber;
+use Fleetbase\LaravelMysqlSpatial\Types\Point;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Query\Expression;
+use Illuminate\Database\Query\Grammars\Grammar;
+
+class FleetOpsTrackingNumberTraitHostFake extends Model
+{
+    use HasTrackingNumber;
+
+    protected $fillable = ['tracking_number_uuid'];
+
+    public bool $saved = false;
+
+    public function save(array $options = []): bool
+    {
+        $this->saved = true;
+
+        return true;
+    }
+}
+
+class FleetOpsTrackingNumberPayloadHostFake extends FleetOpsTrackingNumberTraitHostFake
+{
+    public array $loaded = [];
+
+    public function load($relations): static
+    {
+        $this->loaded = is_array($relations) ? $relations : func_get_args();
+
+        return $this;
+    }
+
+    public function payload(): void
+    {
+    }
+}
+
+function fleetopsTrackingExpressionValue(Expression $expression): string
+{
+    return method_exists($expression, 'getValue') ? $expression->getValue(new Grammar()) : (string) $expression;
+}
+
+test('tracking number trait handles assignment status location and pickup fallbacks', function () {
+    app()->instance('db', new class {
+        public function raw(string $value): Expression
+        {
+            return new Expression($value);
+        }
+    });
+
+    $trackingNumber = new TrackingNumber();
+    $trackingNumber->setRawAttributes(['uuid' => 'tracking-uuid'], true);
+
+    $host = new FleetOpsTrackingNumberTraitHostFake();
+    $host->setTrackingNumber($trackingNumber);
+
+    $filled = new FleetOpsTrackingNumberTraitHostFake();
+    $filled->setRawAttributes(['tracking_number_uuid' => 'existing-tracking'], true);
+    $filled->setTrackingNumber($trackingNumber);
+
+    expect($host->tracking_number_uuid)->toBe('tracking-uuid')
+        ->and($host->trackingNumber)->toBe($trackingNumber)
+        ->and($host->saved)->toBeTrue()
+        ->and($filled->tracking_number_uuid)->toBe('existing-tracking')
+        ->and($filled->saved)->toBeFalse()
+        ->and($host->setStatus('dispatched', false))->toBe($host)
+        ->and($host->status)->toBe('dispatched')
+        ->and($host->getPickupRegion())->toBe('SG')
+        ->and($host->getPickupLocation())->toBeInstanceOf(Point::class)
+        ->and(fleetopsTrackingExpressionValue($host->getLocationAsPoint(null)))->toContain('POINT(0 0)')
+        ->and(fleetopsTrackingExpressionValue($host->getLocationAsPoint([1.31, 103.82])))->toContain('POINT(103.82 1.31)');
+});
+
+test('tracking number trait delegates pickup data to payload relations when present', function () {
+    $payload = new class(new Point(3.13, 101.68)) {
+        public function __construct(public Point $location)
+        {
+        }
+
+        public function getPickupRegion(): string
+        {
+            return 'MY';
+        }
+
+        public function getPickupLocation(): Point
+        {
+            return $this->location;
+        }
+    };
+
+    $host          = new FleetOpsTrackingNumberPayloadHostFake();
+    $host->payload = $payload;
+
+    $proof = new Proof();
+
+    expect($host->getPickupRegion())->toBe('MY')
+        ->and($host->getPickupLocation())->toBe($payload->getPickupLocation())
+        ->and($host->loaded)->toBe(['payload'])
+        ->and(FleetOpsTrackingNumberTraitHostFake::resolveProof($proof))->toBe($proof)
+        ->and(FleetOpsTrackingNumberTraitHostFake::resolveProof(null))->toBeNull();
+});

package/server/tests/Unit/Casts/SpatialCastBranchesTest.php

@@ -0,0 +1,75 @@
+<?php
+
+use Fleetbase\LaravelMysqlSpatial\Eloquent\SpatialExpression;
+use Fleetbase\LaravelMysqlSpatial\Types\MultiPolygon as SpatialMultiPolygon;
+use Fleetbase\LaravelMysqlSpatial\Types\Point as SpatialPoint;
+use Fleetbase\LaravelMysqlSpatial\Types\Polygon as SpatialPolygon;
+
+/**
+ * Covers the spatial cast branches that accept an already-typed geometry:
+ * each cast stashes the geometry on the model so the spatial trait can bind
+ * it at write time, and hands the value straight back.
+ */
+class FleetOpsSpatialCastModel
+{
+    public array $geometries = [];
+}
+
+function fleetopsSpatialCastSquare(): SpatialPolygon
+{
+    return new SpatialPolygon([
+        new Fleetbase\LaravelMysqlSpatial\Types\LineString([
+            new SpatialPoint(1.20, 103.70),
+            new SpatialPoint(1.20, 103.95),
+            new SpatialPoint(1.45, 103.95),
+            new SpatialPoint(1.45, 103.70),
+            new SpatialPoint(1.20, 103.70),
+        ]),
+    ]);
+}
+
+test('typed geometries are stashed on the model and wrapped for binding', function () {
+    // Every spatial type implements GeometryInterface, so polygon geometries
+    // are stashed and wrapped in a spatial expression for the query binding
+    $model    = new FleetOpsSpatialCastModel();
+    $multi    = new SpatialMultiPolygon([fleetopsSpatialCastSquare()]);
+    $returned = (new Fleetbase\FleetOps\Casts\MultiPolygon())->set($model, 'border', $multi, []);
+
+    expect($returned)->toBeInstanceOf(SpatialExpression::class)
+        ->and($model->geometries['border'])->toBe($multi);
+
+    // The polygon cast stashes the geometry but hands the value back directly
+    $polygonModel = new FleetOpsSpatialCastModel();
+    $polygon      = fleetopsSpatialCastSquare();
+    $polygonCast  = (new Fleetbase\FleetOps\Casts\Polygon())->set($polygonModel, 'border', $polygon, []);
+
+    expect($polygonCast)->toBe($polygon)
+        ->and($polygonModel->geometries['border'])->toBe($polygon);
+
+    // Expressions are already bind-ready, so the point cast returns them
+    // untouched — but still stashes them, so the spatial trait can restore the
+    // attribute after an insert like it does for every other spatial input
+    $pointModel = new FleetOpsSpatialCastModel();
+    $expression = new SpatialExpression(new SpatialPoint(1.30, 103.80));
+    $pointCast  = (new Fleetbase\FleetOps\Casts\Point())->set($pointModel, 'location', $expression, []);
+
+    expect($pointCast)->toBe($expression)
+        ->and($pointModel->geometries['location'])->toBe($expression);
+
+    // A bare point is stashed and wrapped for binding
+    $bareModel = new FleetOpsSpatialCastModel();
+    $bare      = new SpatialPoint(1.30, 103.80);
+    expect((new Fleetbase\FleetOps\Casts\Point())->set($bareModel, 'location', $bare, []))->toBeInstanceOf(SpatialExpression::class)
+        ->and($bareModel->geometries['location'])->toBe($bare);
+});
+
+test('raw binary points read back through the point cast', function () {
+    // The driver hands back the packed geometry MySQL stored
+    $raw = pack('V', 0) . pack('C', 1) . pack('V', 1) . pack('d', 103.80) . pack('d', 1.30);
+
+    $point = (new Fleetbase\FleetOps\Casts\Point())->get(new FleetOpsSpatialCastModel(), 'location', $raw, []);
+
+    expect($point)->toBeInstanceOf(SpatialPoint::class)
+        ->and(round($point->getLat(), 2))->toBe(103.80)
+        ->and(round($point->getLng(), 2))->toBe(1.30);
+});

package/server/tests/Unit/Console/AssignCustomerRolesCommandTest.php

@@ -0,0 +1,102 @@
+<?php
+
+use Fleetbase\FleetOps\Console\Commands\AssignCustomerRoles;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+/**
+ * Covers the fleetops:assign-customer-roles command against SQLite: customer
+ * traversal, user resolution with on-demand creation, and the role
+ * assignment error branch when role storage is unavailable in the harness.
+ */
+class FleetOpsAssignCustomerRolesProbe extends AssignCustomerRoles
+{
+    public array $messages = [];
+
+    public function info($string, $verbosity = null)
+    {
+        $this->messages[] = ['info', $string];
+    }
+
+    public function error($string, $verbosity = null)
+    {
+        $this->messages[] = ['error', $string];
+    }
+}
+
+function fleetopsAssignCustomerRolesBoot(): 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();
+    $tables = [
+        'contacts'      => ['uuid', 'public_id', 'company_uuid', 'user_uuid', 'name', 'email', 'phone', 'type', 'meta'],
+        'users'         => ['uuid', 'public_id', 'company_uuid', 'name', 'email', 'phone', 'type', 'status', 'username', 'password'],
+        'companies'     => ['uuid', 'public_id', 'name'],
+        'company_users' => ['uuid', 'company_uuid', 'user_uuid', 'status'],
+    ];
+    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;
+}
+
+test('assign customer roles resolves users and reports assignment errors', function () {
+    $connection = fleetopsAssignCustomerRolesBoot();
+    $connection->table('users')->insert(['uuid' => 'user-1', 'company_uuid' => 'company-1', 'name' => 'Customer User']);
+    $connection->table('contacts')->insert([
+        'uuid'         => 'contact-1',
+        'company_uuid' => 'company-1',
+        'user_uuid'    => 'user-1',
+        'name'         => 'Customer A',
+        'email'        => 'customer@example.test',
+        'type'         => 'customer',
+    ]);
+
+    $command = new FleetOpsAssignCustomerRolesProbe();
+    $result  = $command->handle();
+
+    // Role storage is unavailable in the harness so each customer hits the
+    // error branch after user resolution.
+    expect($result)->toBe(0)
+        ->and(collect($command->messages)->where(0, 'error')->count())->toBe(1);
+});
+
+test('assign customer roles completes quietly without customers', function () {
+    fleetopsAssignCustomerRolesBoot();
+
+    $command = new FleetOpsAssignCustomerRolesProbe();
+
+    expect($command->handle())->toBe(0)
+        ->and($command->messages)->toBe([]);
+});

package/server/tests/Unit/Console/AssignDriverRolesCommandTest.php

@@ -0,0 +1,113 @@
+<?php
+
+use Fleetbase\FleetOps\Console\Commands\AssignDriverRoles;
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\Models\User;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+/**
+ * Covers the fleetops:assign-driver-roles command against SQLite: company
+ * traversal with user/driver matching, the admin skip, and the error branch
+ * when role assignment is unavailable in the harness.
+ */
+class FleetOpsAssignDriverRolesProbe extends AssignDriverRoles
+{
+    public array $messages = [];
+
+    public function info($string, $verbosity = null)
+    {
+        $this->messages[] = ['info', $string];
+    }
+
+    public function error($string, $verbosity = null)
+    {
+        $this->messages[] = ['error', $string];
+    }
+}
+
+function fleetopsAssignDriverRolesBoot(): 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();
+    $tables = [
+        'companies'     => ['uuid', 'public_id', 'name', 'owner_uuid'],
+        'company_users' => ['uuid', 'company_uuid', 'user_uuid', 'status'],
+        'users'         => ['uuid', 'public_id', 'company_uuid', 'name', 'email', 'type', 'status'],
+        'drivers'       => ['uuid', 'public_id', 'company_uuid', 'user_uuid', 'status'],
+    ];
+    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();
+        });
+    }
+
+    User::expand('driver', function () {
+        return $this->hasOne(Driver::class, 'user_uuid', 'uuid')->withoutGlobalScopes();
+    });
+
+    session(['company' => 'company-1']);
+
+    return $connection;
+}
+
+test('assign driver roles walks companies and reports assignment errors', function () {
+    $connection = fleetopsAssignDriverRolesBoot();
+    $connection->table('companies')->insert(['uuid' => 'company-1', 'name' => 'Acme']);
+    $connection->table('users')->insert([
+        ['uuid' => 'user-1', 'company_uuid' => 'company-1', 'name' => 'Driver User', 'email' => 'driver@example.test', 'type' => 'user'],
+        ['uuid' => 'user-2', 'company_uuid' => 'company-1', 'name' => 'Admin User', 'email' => 'admin@example.test', 'type' => 'admin'],
+    ]);
+    $connection->table('company_users')->insert([
+        ['uuid' => 'cu-1', 'company_uuid' => 'company-1', 'user_uuid' => 'user-1'],
+        ['uuid' => 'cu-2', 'company_uuid' => 'company-1', 'user_uuid' => 'user-2'],
+    ]);
+    $connection->table('drivers')->insert([
+        ['uuid' => 'driver-1', 'company_uuid' => 'company-1', 'user_uuid' => 'user-1', 'status' => 'active'],
+        ['uuid' => 'driver-2', 'company_uuid' => 'company-1', 'user_uuid' => 'user-2', 'status' => 'active'],
+    ]);
+
+    $command = new FleetOpsAssignDriverRolesProbe();
+    $result  = $command->handle();
+
+    // Role storage is unavailable in the harness, so the driver user hits
+    // the error branch; the admin user is skipped before role assignment.
+    expect($result)->toBe(0)
+        ->and(collect($command->messages)->where(0, 'error')->count())->toBeGreaterThanOrEqual(1)
+        ->and(collect($command->messages)->where(0, 'info')->count())->toBe(0);
+});
+
+test('assign driver roles completes quietly with no companies', function () {
+    fleetopsAssignDriverRolesBoot();
+
+    $command = new FleetOpsAssignDriverRolesProbe();
+
+    expect($command->handle())->toBe(0)
+        ->and($command->messages)->toBe([]);
+});

package/server/tests/Unit/Console/Commands/FixLegacyOrderConfigsHelpersTest.php

@@ -0,0 +1,108 @@
+<?php
+
+use Fleetbase\FleetOps\Console\Commands\FixLegacyOrderConfigs;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+/**
+ * Covers the real protected helper bodies on FixLegacyOrderConfigs:
+ * companies(), createTransportConfig(), ordersWithoutConfig(),
+ * transportConfigForCompany(), and createProgressBar().
+ */
+if (!EloquentModel::getEventDispatcher()) {
+    EloquentModel::setEventDispatcher(new Illuminate\Events\Dispatcher());
+}
+
+test('legacy order config command helpers query and create through the real bodies', function () {
+    $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');
+    app()->instance('responsecache', new class {
+        public function __call($method, $arguments)
+        {
+            return null;
+        }
+    });
+    config()->set('activitylog.enabled', false);
+    config()->set('activitylog.default_auth_driver', 'web');
+    app()->bind(Illuminate\Contracts\Config\Repository::class, fn () => config());
+
+    $schema = $connection->getSchemaBuilder();
+    $schema->create('companies', function ($blueprint) {
+        $blueprint->increments('id');
+        foreach (['uuid', 'public_id', 'name', 'country', 'options'] as $column) {
+            $blueprint->string($column)->nullable();
+        }
+        $blueprint->timestamps();
+        $blueprint->timestamp('deleted_at')->nullable();
+    });
+    $schema->create('order_configs', function ($blueprint) {
+        $blueprint->increments('id');
+        foreach (['uuid', 'public_id', 'company_uuid', 'created_by_uuid', 'author_uuid', 'category_uuid', 'icon_uuid', 'name', 'key', 'namespace', 'description', 'tags', 'flow', 'entities', 'meta', 'version', 'status', 'type', '_key'] as $column) {
+            $blueprint->string($column)->nullable();
+        }
+        $blueprint->integer('core_service')->nullable();
+        $blueprint->timestamps();
+        $blueprint->timestamp('deleted_at')->nullable();
+    });
+    $schema->create('orders', function ($blueprint) {
+        $blueprint->increments('id');
+        foreach (['uuid', 'public_id', 'company_uuid', 'order_config_uuid', 'status', 'type', '_key'] as $column) {
+            $blueprint->string($column)->nullable();
+        }
+        $blueprint->timestamps();
+        $blueprint->timestamp('deleted_at')->nullable();
+    });
+
+    $connection->table('companies')->insert(['uuid' => 'company-legacy-1', 'name' => 'Legacy Co']);
+    $connection->table('orders')->insert([
+        ['uuid' => 'order-legacy-1', 'company_uuid' => 'company-legacy-1', 'order_config_uuid' => null],
+        ['uuid' => 'order-legacy-2', 'company_uuid' => 'company-legacy-1', 'order_config_uuid' => 'config-existing'],
+    ]);
+
+    $command = new FixLegacyOrderConfigs();
+    $invoke  = function (string $method, array $arguments = []) use ($command) {
+        $reflection = new ReflectionMethod(FixLegacyOrderConfigs::class, $method);
+        $reflection->setAccessible(true);
+
+        return $reflection->invoke($command, ...$arguments);
+    };
+
+    $companies = $invoke('companies');
+    expect($companies)->toHaveCount(1);
+
+    $invoke('createTransportConfig', [$companies->first()]);
+    expect($connection->table('order_configs')->where('namespace', 'system:order-config:transport')->count())->toBe(1);
+
+    $config = $invoke('transportConfigForCompany', ['company-legacy-1']);
+    expect($config)->toBeInstanceOf(Fleetbase\FleetOps\Models\OrderConfig::class)
+        ->and($invoke('transportConfigForCompany', ['company-missing']))->toBeNull();
+
+    $orders = $invoke('ordersWithoutConfig');
+    expect($orders)->toHaveCount(1)
+        ->and($orders->first()->uuid)->toBe('order-legacy-1');
+
+    $command->setOutput(new Illuminate\Console\OutputStyle(
+        new Symfony\Component\Console\Input\ArrayInput([]),
+        new Symfony\Component\Console\Output\BufferedOutput()
+    ));
+    expect($invoke('createProgressBar', [3]))->toBeInstanceOf(Symfony\Component\Console\Helper\ProgressBar::class);
+});