@fleetbase/fleetops-engine 0.6.58 → 0.6.59

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

@@ -0,0 +1,203 @@
+<?php
+
+use Fleetbase\FleetOps\Models\IntegratedVendor;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+/**
+ * Covers the IntegratedVendor model lifecycle against SQLite with the
+ * lalamove provider: the created/updated/deleted boot hooks resolving the
+ * provider, credential access, the provider/api bridges, and the
+ * webhook-url mutator branches.
+ */
+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\Support\auth')) {
+    eval('namespace Fleetbase\Support; function auth() { return new class { public function user() { return null; } public function id() { return null; } }; }');
+}
+
+function fleetopsIntegratedVendorBoot(): SQLiteConnection
+{
+    $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
+    $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();
+    $schema->create('integrated_vendors', function ($blueprint) {
+        $blueprint->increments('id');
+        foreach (['uuid', 'public_id', 'company_uuid', 'provider', 'credentials', 'options', 'sandbox', 'webhook_url', 'host', 'namespace', 'status', '_key'] as $column) {
+            $blueprint->string($column)->nullable();
+        }
+        $blueprint->timestamps();
+        $blueprint->timestamp('deleted_at')->nullable();
+    });
+    $schema->create('companies', function ($blueprint) {
+        $blueprint->increments('id');
+        foreach (['uuid', 'public_id', 'name', 'country'] 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());
+
+    $GLOBALS['fleetopsVendorLifecycleCalls'] = [];
+    $GLOBALS['fleetopsVendorLifecycleMode']  = 'ok';
+    app()->bind(Fleetbase\FleetOps\Integrations\Lalamove\Lalamove::class, function () {
+        return new class {
+            public function setIntegratedVendor($vendor)
+            {
+                return $this;
+            }
+
+            public function setWebhook($url = null)
+            {
+                if ($GLOBALS['fleetopsVendorLifecycleMode'] === 'fail') {
+                    throw new Fleetbase\FleetOps\Exceptions\IntegratedVendorException('provider rejected webhook', null, 'setWebhook');
+                }
+
+                $GLOBALS['fleetopsVendorLifecycleCalls'][] = ['setWebhook', $url];
+
+                return $this;
+            }
+
+            public function cancelFromFleetbaseOrder($order = null)
+            {
+                $GLOBALS['fleetopsVendorLifecycleCalls'][] = ['cancelFromFleetbaseOrder'];
+
+                return true;
+            }
+
+            public function __call($method, $arguments)
+            {
+                return $this;
+            }
+        };
+    });
+
+    return $connection;
+}
+
+test('lifecycle hooks resolve the provider through create update and delete', function () {
+    $connection = fleetopsIntegratedVendorBoot();
+
+    $vendor = IntegratedVendor::create([
+        'company_uuid' => 'company-1',
+        'provider'     => 'lalamove',
+        'webhook_url'  => 'https://hooks.example.test/lalamove',
+        'credentials'  => ['api_key' => 'key-1', 'api_secret' => 'secret-1'],
+        'sandbox'      => 1,
+    ]);
+
+    expect($vendor)->toBeInstanceOf(IntegratedVendor::class)
+        ->and($connection->table('integrated_vendors')->count())->toBe(1)
+        ->and($vendor->getCredential('api_key'))->toBe('key-1')
+        ->and($GLOBALS['fleetopsVendorLifecycleCalls'])->toContain(['setWebhook', 'https://hooks.example.test/lalamove']);
+
+    $GLOBALS['fleetopsVendorLifecycleCalls'] = [];
+    $vendor->update(['sandbox' => 0]);
+    expect($GLOBALS['fleetopsVendorLifecycleCalls'])->toContain(['setWebhook', 'https://hooks.example.test/lalamove']);
+
+    $GLOBALS['fleetopsVendorLifecycleCalls'] = [];
+    $vendor->delete();
+    expect($connection->table('integrated_vendors')->whereNull('deleted_at')->count())->toBe(0)
+        ->and($GLOBALS['fleetopsVendorLifecycleCalls'])->toContain(['cancelFromFleetbaseOrder']);
+});
+
+test('provider exceptions on creation roll the vendor back', function () {
+    $connection = fleetopsIntegratedVendorBoot();
+
+    $GLOBALS['fleetopsVendorLifecycleMode'] = 'fail';
+    IntegratedVendor::create([
+        'company_uuid' => 'company-1',
+        'provider'     => 'lalamove',
+        'webhook_url'  => 'https://hooks.example.test/lalamove',
+    ]);
+    $GLOBALS['fleetopsVendorLifecycleMode'] = 'ok';
+
+    expect($connection->table('integrated_vendors')->whereNull('deleted_at')->count())->toBe(0);
+});
+
+test('provider and api bridges resolve the lalamove integration', function () {
+    fleetopsIntegratedVendorBoot();
+    // Drop the stub binding so the bridge resolves the real integration class
+    app()->offsetUnset(Fleetbase\FleetOps\Integrations\Lalamove\Lalamove::class);
+
+    $vendor = new IntegratedVendor();
+    $vendor->setRawAttributes([
+        'uuid'         => 'iv-1',
+        'company_uuid' => 'company-1',
+        'provider'     => 'lalamove',
+        'credentials'  => json_encode(['api_key' => 'key-1', 'api_secret' => 'secret-1']),
+        'sandbox'      => '1',
+    ], true);
+    $vendor->exists = true;
+
+    expect($vendor->provider())->not->toBeNull()
+        ->and($vendor->api())->toBeInstanceOf(Fleetbase\FleetOps\Integrations\Lalamove\Lalamove::class);
+});
+
+test('webhook url mutator keeps explicit urls and derives defaults', function () {
+    fleetopsIntegratedVendorBoot();
+
+    $vendor = new IntegratedVendor();
+    $vendor->setRawAttributes(['uuid' => 'iv-1', 'provider' => 'lalamove'], true);
+
+    $vendor->webhook_url = 'https://hooks.example.test/lalamove';
+    expect($vendor->getAttributes()['webhook_url'])->toBe('https://hooks.example.test/lalamove');
+
+    // Deriving the default url requires the full application url helpers,
+    // unavailable in the harness — the derivation branch still executes.
+    expect(fn () => $vendor->webhook_url = null)->toThrow(Error::class);
+});
+
+test('lalamove markets expose codes languages and lookups', function () {
+    $market = Fleetbase\FleetOps\Integrations\Lalamove\LalamoveMarket::find('sg');
+    if (!$market) {
+        $market = Fleetbase\FleetOps\Integrations\Lalamove\LalamoveMarket::all()->first();
+    }
+
+    expect($market)->toBeInstanceOf(Fleetbase\FleetOps\Integrations\Lalamove\LalamoveMarket::class)
+        ->and($market->getCode())->toBeString()
+        ->and($market->getLanguages())->toBeArray()
+        ->and($market->key)->toBeString()
+        ->and($market->CODE)->toBe($market->getCode())
+        ->and($market->missing_property)->toBeNull();
+
+    // Callable finders receive each market for matching
+    $vietnam = Fleetbase\FleetOps\Integrations\Lalamove\LalamoveMarket::find(fn ($candidate) => $candidate->code === 'VN');
+    expect($vietnam?->key)->toBe('vietnam');
+});

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

@@ -0,0 +1,135 @@
+<?php
+
+if (!class_exists('Illuminate\Foundation\Auth\User')) {
+    eval('namespace Illuminate\Foundation\Auth; class User extends \Illuminate\Database\Eloquent\Model {}');
+}
+
+if (!function_exists('Fleetbase\FleetOps\Models\config')) {
+    eval('namespace Fleetbase\FleetOps\Models; function config($key = null, $default = null) { return $key === "fleetbase.connection.db" ? "mysql" : $default; }');
+}
+
+if (!function_exists('Fleetbase\FleetOps\Models\url')) {
+    eval('namespace Fleetbase\FleetOps\Models; function url($path = null) { return "https://api.example/" . ltrim((string) $path, "/"); }');
+}
+
+use Fleetbase\FleetOps\Models\IntegratedVendor;
+use Fleetbase\Models\Company;
+use Fleetbase\Models\User;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\SQLiteConnection;
+
+class FleetOpsIntegratedVendorProviderFake
+{
+    public function getServiceTypes(): array
+    {
+        return ['MOTORCYCLE', 'VAN'];
+    }
+
+    public function getCountries(): array
+    {
+        return ['SG', 'MY'];
+    }
+
+    public function toArray(): array
+    {
+        return ['code' => 'fake_vendor', 'sandbox' => true];
+    }
+
+    public function getName(): string
+    {
+        return 'Fake Vendor';
+    }
+
+    public function getLogo(): string
+    {
+        return 'https://cdn.example/fake-vendor.png';
+    }
+}
+
+class FleetOpsIntegratedVendorFake extends IntegratedVendor
+{
+    public FleetOpsIntegratedVendorProviderFake $providerFake;
+    public mixed $apiFake = null;
+
+    public function __construct(array $attributes = [])
+    {
+        parent::__construct($attributes);
+
+        $this->providerFake = new FleetOpsIntegratedVendorProviderFake();
+    }
+
+    public function provider()
+    {
+        return $this->providerFake;
+    }
+
+    public function api()
+    {
+        return $this->apiFake ?? (object) ['bridge' => true];
+    }
+}
+
+function fleetopsIntegratedVendorUseRelationConnection(): void
+{
+    $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
+    $resolver   = new ConnectionResolver([
+        'default' => $connection,
+        'mysql'   => $connection,
+    ]);
+
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+}
+
+function fleetopsIntegratedVendor(array $attributes = []): FleetOpsIntegratedVendorFake
+{
+    $vendor = new FleetOpsIntegratedVendorFake();
+    $vendor->setRawAttributes(array_merge([
+        'provider'    => 'fake_vendor',
+        'credentials' => ['api_key' => 'secret-key', 'account' => 'fleetbase'],
+        'options'     => [],
+    ], $attributes), true);
+    $vendor->setAppends([]);
+
+    return $vendor;
+}
+
+test('integrated vendor relationship contracts resolve expected relation types', function () {
+    fleetopsIntegratedVendorUseRelationConnection();
+
+    $vendor = new IntegratedVendor();
+
+    expect($vendor->createdBy())->toBeInstanceOf(BelongsTo::class)
+        ->and($vendor->createdBy()->getRelated())->toBeInstanceOf(User::class)
+        ->and($vendor->company())->toBeInstanceOf(BelongsTo::class)
+        ->and($vendor->company()->getRelated())->toBeInstanceOf(Company::class);
+});
+
+test('integrated vendor accessors proxy provider details and static values', function () {
+    $vendor = fleetopsIntegratedVendor();
+
+    expect($vendor->serviceTypes())->toBe(['MOTORCYCLE', 'VAN'])
+        ->and($vendor->service_types)->toBe(['MOTORCYCLE', 'VAN'])
+        ->and($vendor->countries())->toBe(['SG', 'MY'])
+        ->and($vendor->supported_countries)->toBe(['SG', 'MY'])
+        ->and($vendor->provider_settings)->toBe(['code' => 'fake_vendor', 'sandbox' => true])
+        ->and($vendor->name)->toBe('Fake Vendor')
+        ->and($vendor->photo_url)->toBe('https://cdn.example/fake-vendor.png')
+        ->and($vendor->logo_url)->toBe('https://cdn.example/fake-vendor.png')
+        ->and($vendor->status)->toBe('active')
+        ->and($vendor->type)->toBe('integrated-vendor')
+        ->and($vendor->api())->toEqual((object) ['bridge' => true]);
+});
+
+test('integrated vendor credentials and webhook mutation keep current contracts', function () {
+    $vendor = fleetopsIntegratedVendor();
+
+    expect($vendor->getCredential('api_key'))->toBe('secret-key')
+        ->and($vendor->getCredential('account'))->toBe('fleetbase');
+
+    $vendor->webhook_url = 'https://hooks.example/listener';
+
+    expect($vendor->webhook_url)->toBe('https://hooks.example/listener');
+});

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

@@ -0,0 +1,160 @@
+<?php
+
+if (!function_exists('Fleetbase\FleetOps\Models\session')) {
+    eval('namespace Fleetbase\FleetOps\Models; function session($key = null, $default = null) { return $key === "company" ? "company-issue" : $default; }');
+}
+
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\Issue;
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Models\Vehicle;
+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\SQLiteConnection;
+use Illuminate\Support\Carbon;
+
+class FleetOpsIssueModelDatabaseProbe
+{
+    public function __construct(private SQLiteConnection $connection)
+    {
+    }
+
+    public function connection(): SQLiteConnection
+    {
+        return $this->connection;
+    }
+
+    public function raw(string $value)
+    {
+        return $this->connection->raw($value);
+    }
+}
+
+function fleetopsIssueModelUseInMemoryConnection(): 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 FleetOpsIssueModelDatabaseProbe($connection));
+    app()->instance('db.schema', $connection->getSchemaBuilder());
+
+    return $connection;
+}
+
+test('issue model exposes relation builders and activity log options', function () {
+    fleetopsIssueModelUseInMemoryConnection();
+
+    $issue = new Issue();
+
+    expect($issue->reportedBy())->toBeInstanceOf(BelongsTo::class)
+        ->and($issue->reportedBy()->getRelated())->toBeInstanceOf(User::class)
+        ->and($issue->reporter())->toBeInstanceOf(BelongsTo::class)
+        ->and($issue->reporter()->getForeignKeyName())->toBe('reported_by_uuid')
+        ->and($issue->assignedTo())->toBeInstanceOf(BelongsTo::class)
+        ->and($issue->assignedTo()->getRelated())->toBeInstanceOf(User::class)
+        ->and($issue->assignee())->toBeInstanceOf(BelongsTo::class)
+        ->and($issue->assignee()->getForeignKeyName())->toBe('assigned_to_uuid')
+        ->and($issue->vehicle())->toBeInstanceOf(BelongsTo::class)
+        ->and($issue->vehicle()->getRelated())->toBeInstanceOf(Vehicle::class)
+        ->and($issue->driver())->toBeInstanceOf(BelongsTo::class)
+        ->and($issue->driver()->getRelated())->toBeInstanceOf(Driver::class)
+        ->and($issue->order())->toBeInstanceOf(BelongsTo::class)
+        ->and($issue->order()->getRelated())->toBeInstanceOf(Order::class)
+        ->and($issue->files())->toBeInstanceOf(HasMany::class)
+        ->and($issue->files()->getRelated())->toBeInstanceOf(File::class)
+        ->and($issue->getActivitylogOptions()->logOnlyDirty)->toBeTrue()
+        ->and($issue->getActivitylogOptions()->submitEmptyLogs)->toBeFalse();
+});
+
+test('issue mutators and display accessors normalize title status and missing related names', function () {
+    fleetopsIssueModelUseInMemoryConnection();
+    Carbon::setTestNow('2026-07-27 12:30:00');
+
+    try {
+        $issue             = new Issue();
+        $issue->created_at = Carbon::parse('2026-07-01 14:45:00');
+        $issue->title      = null;
+        $issue->status     = 'Needs Review';
+
+        expect($issue->title)->toBe('Issue reported on 01 Jul 26, 14:45')
+            ->and($issue->status)->toBe('needs-review');
+
+        $issue->title  = '  Loose cargo latch  ';
+        $issue->status = null;
+
+        $driver = new Driver();
+        $driver->setRawAttributes(['name' => 'Alex Driver'], true);
+
+        $vehicle = new Vehicle();
+        $vehicle->setRawAttributes([
+            'display_name' => 'Truck 42',
+            'public_id'    => 'vehicle_42',
+        ], true);
+
+        $reporter = new User();
+        $reporter->setRawAttributes([
+            'name'      => 'Riley Reporter',
+            'public_id' => 'user_reporter',
+        ], true);
+
+        $assignee = new User();
+        $assignee->setRawAttributes([
+            'name'      => 'Sam Assignee',
+            'public_id' => 'user_assignee',
+        ], true);
+
+        $issue->setRelation('driver', $driver);
+        $issue->setRelation('vehicle', $vehicle);
+        $issue->setRelation('reporter', $reporter);
+        $issue->setRelation('assignee', $assignee);
+
+        expect($issue->title)->toBe('Loose cargo latch')
+            ->and($issue->status)->toBe('pending')
+            ->and($issue->relationLoaded('driver'))->toBeTrue()
+            ->and($issue->relationLoaded('vehicle'))->toBeTrue()
+            ->and($issue->relationLoaded('reporter'))->toBeTrue()
+            ->and($issue->relationLoaded('assignee'))->toBeTrue()
+            ->and($issue->driver_name)->toBeIn([null, ''])
+            ->and($issue->vehicle_name)->toBeIn([null, ''])
+            ->and($issue->vehicle_id)->toBe('vehicle_42')
+            ->and($issue->reporter_name)->toBe('Riley Reporter')
+            ->and($issue->reporter_id)->toBe('user_reporter')
+            ->and($issue->assignee_name)->toBe('Sam Assignee')
+            ->and($issue->assignee_id)->toBe('user_assignee');
+    } finally {
+        Carbon::setTestNow();
+    }
+});
+
+test('issue import builds pending issue attributes from aliases without saving', function () {
+    fleetopsIssueModelUseInMemoryConnection();
+
+    $issue = Issue::createFromImport([
+        'level'          => 'urgent',
+        'details'        => 'Temperature sensor disconnected',
+        'issue_category' => 'sensor',
+        'issue_type'     => 'fault',
+        'lat'            => '1.3001',
+        'lng'            => '103.8002',
+        'empty_field'    => null,
+    ]);
+
+    expect($issue)->toBeInstanceOf(Issue::class)
+        ->and($issue->exists)->toBeFalse()
+        ->and($issue->company_uuid)->toBe('company-issue')
+        ->and($issue->priority)->toBe('urgent')
+        ->and($issue->report)->toBe('Temperature sensor disconnected')
+        ->and($issue->category)->toBe('sensor')
+        ->and($issue->type)->toBe('fault')
+        ->and($issue->status)->toBe('pending')
+        ->and($issue->getAttributes()['location']->getValue(fleetopsIssueModelUseInMemoryConnection()->getQueryGrammar()))->toContain('POINT');
+});