@fleetbase/fleetops-engine 0.6.58 → 0.6.59

package/server/tests/OrderFilterExecutionTest.php

@@ -0,0 +1,244 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Filter\OrderFilter;
+use Illuminate\Http\Request;
+use Illuminate\Support\Str;
+
+class FleetOpsRecordingOrderFilterBuilder
+{
+    public array $calls = [];
+
+    public function search($query, ?Closure $callback = null)
+    {
+        $this->calls[] = ['search', $query];
+
+        if ($callback) {
+            $callback($this, $query);
+        }
+
+        return $this;
+    }
+
+    public function where($column, ...$args)
+    {
+        $this->calls[] = ['where', $column, $args];
+        $this->invokeNested($column);
+
+        return $this;
+    }
+
+    public function orWhere($column, ...$args)
+    {
+        $this->calls[] = ['orWhere', $column, $args];
+        $this->invokeNested($column);
+
+        return $this;
+    }
+
+    public function whereHas($relation, ?Closure $callback = null)
+    {
+        $nested        = new self();
+        $this->calls[] = ['whereHas', $relation, $nested];
+        $callback?->call($this, $nested);
+
+        return $this;
+    }
+
+    public function orWhereHas($relation, ?Closure $callback = null)
+    {
+        $nested        = new self();
+        $this->calls[] = ['orWhereHas', $relation, $nested];
+        $callback?->call($this, $nested);
+
+        return $this;
+    }
+
+    public function whereDoesntHave($relation, ?Closure $callback = null)
+    {
+        $nested        = new self();
+        $this->calls[] = ['whereDoesntHave', $relation, $nested];
+        $callback?->call($this, $nested);
+
+        return $this;
+    }
+
+    public function removeWhereFromQuery($column, $value)
+    {
+        $this->calls[] = ['removeWhereFromQuery', $column, $value];
+
+        return $this;
+    }
+
+    public function __call($method, $arguments)
+    {
+        $this->calls[] = [$method, ...$arguments];
+
+        foreach ($arguments as $argument) {
+            $this->invokeNested($argument);
+        }
+
+        return $this;
+    }
+
+    public function methodCalls(string $method): array
+    {
+        return array_values(array_filter($this->calls, fn ($call) => $call[0] === $method));
+    }
+
+    public function called(string $method): bool
+    {
+        return !empty($this->methodCalls($method));
+    }
+
+    private function invokeNested($value): void
+    {
+        if (!$value instanceof Closure) {
+            return;
+        }
+
+        $reflection = new ReflectionFunction($value);
+        if ($reflection->getNumberOfParameters() > 0) {
+            $value($this);
+
+            return;
+        }
+
+        $value();
+    }
+}
+
+function fleetopsOrderFilter(FleetOpsRecordingOrderFilterBuilder $builder, array $query = []): OrderFilter
+{
+    $request = Request::create('/int/v1/orders', 'GET', $query);
+    $session = app('session.store');
+    $session->put('company', 'company_test');
+    $request->setLaravelSession($session);
+
+    $filter = new OrderFilter($request);
+
+    $reflection = new ReflectionClass($filter);
+    $property   = $reflection->getParentClass()->getProperty('builder');
+    $property->setAccessible(true);
+    $property->setValue($filter, $builder);
+
+    return $filter;
+}
+
+test('order filter applies internal and public base scopes with eager loading', function () {
+    $builder = new FleetOpsRecordingOrderFilterBuilder();
+    $filter  = fleetopsOrderFilter($builder);
+
+    $filter->queryForInternal();
+    $filter->queryForPublic();
+
+    expect($builder->called('where'))->toBeTrue()
+        ->and($builder->methodCalls('where')[0][1])->toBe('orders.company_uuid')
+        ->and($builder->called('whereHas'))->toBeTrue()
+        ->and($builder->called('with'))->toBeTrue();
+});
+
+test('order filter search and assignment status filters execute nested query branches', function () {
+    $builder = new FleetOpsRecordingOrderFilterBuilder();
+    $filter  = fleetopsOrderFilter($builder);
+
+    $filter->query('needle');
+    $filter->unassigned(true);
+    $filter->unassigned(false);
+    $filter->active(true);
+    $filter->active(false);
+    $filter->tracking('TRACK123');
+
+    expect($builder->called('search'))->toBeTrue()
+        ->and($builder->called('whereDoesntHave'))->toBeTrue()
+        ->and($builder->called('whereNotIn'))->toBeTrue()
+        ->and($builder->called('whereHas'))->toBeTrue();
+});
+
+test('order filter identity and relation filters support uuid and public identifiers', function () {
+    $builder = new FleetOpsRecordingOrderFilterBuilder();
+    $filter  = fleetopsOrderFilter($builder);
+    $uuid    = (string) Str::uuid();
+
+    $filter->status('active');
+    $filter->status(['created', 'started']);
+    $filter->customer('customer_uuid');
+    $filter->authenticatedCustomer('user_uuid');
+    $filter->facilitator('facilitator_uuid');
+    $filter->type('transport');
+    $filter->orderConfig('transport');
+    $filter->payload($uuid);
+    $filter->payload('payload_public');
+    $filter->only(['order_one', 'order_two']);
+    $filter->pickup($uuid);
+    $filter->pickup('pickup_public');
+    $filter->dropoff($uuid);
+    $filter->dropoff('dropoff_public');
+    $filter->return($uuid);
+    $filter->return('return_public');
+    $filter->vehicle($uuid);
+    $filter->vehicle('vehicle_public');
+    $filter->driver($uuid);
+    $filter->driver('driver_public');
+    $filter->driverAssigned('driver_public');
+
+    expect($builder->called('whereIn'))->toBeTrue()
+        ->and($builder->called('removeWhereFromQuery'))->toBeTrue()
+        ->and($builder->called('whereHas'))->toBeTrue()
+        ->and($builder->called('orWhereHas'))->toBeTrue();
+});
+
+test('order filter sort exclude bulk and date filters execute their query operations', function () {
+    $builder = new FleetOpsRecordingOrderFilterBuilder();
+    $filter  = fleetopsOrderFilter($builder);
+    $uuid    = (string) Str::uuid();
+
+    foreach (['tracking:asc', 'customer:desc', 'facilitator:asc', 'pickup:desc', 'dropoff:asc'] as $sort) {
+        $filter->sort($sort);
+    }
+
+    $filter->exclude([$uuid, (string) Str::uuid()]);
+    $filter->exclude(['order_public']);
+    $filter->bulkQuery(['order_public']);
+    $filter->bulkQuery([$uuid]);
+    $filter->bulkQuery(['internal_1']);
+    $filter->createdAt('2026-01-01');
+    $filter->updatedAt(['2026-01-01', '2026-01-31']);
+    $filter->scheduledAt(['2026-02-01', '2026-02-02']);
+    $filter->withoutDriver(true);
+    $filter->withoutDriver(false);
+
+    expect($builder->called('join'))->toBeTrue()
+        ->and($builder->called('orderBy'))->toBeTrue()
+        ->and($builder->called('whereNotIn'))->toBeTrue()
+        ->and($builder->called('whereDate'))->toBeTrue()
+        ->and($builder->called('whereBetween'))->toBeTrue()
+        ->and($builder->called('whereNull'))->toBeTrue();
+});
+
+test('order filter inverse date branches bulk public ids and eager scopes', function () {
+    $builder = new FleetOpsRecordingOrderFilterBuilder();
+    $filter  = fleetopsOrderFilter($builder);
+
+    // Inverse date branches and valid public-id bulk lookups
+    $filter->createdAt(['2026-01-01', '2026-01-31']);
+    $filter->updatedAt('2026-02-15');
+    $filter->scheduledAt('2026-02-20');
+    $filter->bulkQuery(['order_bulkhash01', 'order_bulkhash02']);
+
+    expect(collect($builder->methodCalls('whereBetween'))->count())->toBeGreaterThanOrEqual(1)
+        ->and(collect($builder->methodCalls('whereDate'))->count())->toBeGreaterThanOrEqual(2)
+        ->and($builder->called('whereIn'))->toBeTrue();
+
+    // The internal eager-load prunes driver and vehicle sub-relations
+    $scoped       = new FleetOpsRecordingOrderFilterBuilder();
+    $scopedFilter = fleetopsOrderFilter($scoped);
+    $scopedFilter->queryForInternal();
+    $withCall  = collect($scoped->methodCalls('with'))->first();
+    $relations = $withCall[1] ?? [];
+    foreach (['driverAssigned', 'vehicleAssigned'] as $relation) {
+        if (isset($relations[$relation]) && $relations[$relation] instanceof Closure) {
+            $relations[$relation]($scoped);
+        }
+    }
+    expect(collect($scoped->methodCalls('without'))->count())->toBeGreaterThanOrEqual(2);
+});

package/server/tests/OrderQueuedClosureRegressionTest.php

@@ -16,7 +16,8 @@ test('order workflows dispatch named queue jobs instead of signed closures', fun
         ->and($internalController)
         ->not->toContain('dispatch(function')
         ->toContain('FinalizeInternalOrderCreation::dispatch($order->uuid)->afterCommit()')
-        ->toContain('NotifyBulkAssignedDriver::dispatch($orderUuids->all(), $driver->uuid)->afterCommit()');
+        ->toContain('$this->dispatchBulkAssignedDriverNotification($orderUuids->all(), $driver)')
+        ->toContain('NotifyBulkAssignedDriver::dispatch($orderUuids, $driver->uuid)->afterCommit()');
 });
 
 test('order queue jobs serialize only scalar identifiers and options', function () {

package/server/tests/PaymentControllerContractsTest.php

@@ -0,0 +1,199 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\PaymentController;
+
+class FleetOpsPaymentControllerProbe extends PaymentController
+{
+    public mixed $company;
+    public mixed $stripe;
+
+    public function callHelper(string $method, mixed ...$arguments): mixed
+    {
+        $reflection = new ReflectionMethod(PaymentController::class, $method);
+        $reflection->setAccessible(true);
+
+        return $reflection->invoke($this, ...$arguments);
+    }
+
+    protected function getCompany(): mixed
+    {
+        return $this->company ?? null;
+    }
+
+    protected function stripeClient(): mixed
+    {
+        return $this->stripe;
+    }
+
+    protected function jsonResponse(array $payload)
+    {
+        return ['json' => $payload];
+    }
+
+    protected function errorResponse(string $message)
+    {
+        return ['error' => $message];
+    }
+}
+
+class FleetOpsPaymentCompanyFake
+{
+    public array $updates = [];
+
+    public function __construct(public ?string $stripe_connect_id = null)
+    {
+    }
+
+    public function update(array $attributes): bool
+    {
+        $this->updates[] = $attributes;
+        foreach ($attributes as $key => $value) {
+            $this->{$key} = $value;
+        }
+
+        return true;
+    }
+}
+
+class FleetOpsPaymentStripeFake
+{
+    public object $accounts;
+    public object $accountSessions;
+
+    public function __construct(?Throwable $accountError = null, ?Throwable $sessionError = null)
+    {
+        $this->accounts = new class($accountError) {
+            public array $creates = [];
+
+            public function __construct(private ?Throwable $error)
+            {
+            }
+
+            public function create(array $payload): object
+            {
+                if ($this->error) {
+                    throw $this->error;
+                }
+
+                $this->creates[] = $payload;
+
+                return (object) ['id' => 'acct_created'];
+            }
+        };
+
+        $this->accountSessions = new class($sessionError) {
+            public array $creates = [];
+
+            public function __construct(private ?Throwable $error)
+            {
+            }
+
+            public function create(array $payload): object
+            {
+                if ($this->error) {
+                    throw $this->error;
+                }
+
+                $this->creates[] = $payload;
+
+                return (object) ['client_secret' => 'session_secret'];
+            }
+        };
+    }
+}
+
+test('payment controller recognizes Stripe Connect account ids', function (?string $accountId, bool $expected) {
+    $controller = new FleetOpsPaymentControllerProbe();
+
+    expect($controller->callHelper('hasStripeConnectId', $accountId))->toBe($expected);
+})->with([
+    'valid connect id' => ['acct_123', true],
+    'empty id'         => ['', false],
+    'null id'          => [null, false],
+    'customer id'      => ['cus_123', false],
+]);
+
+test('payment controller totals received payments by service quote currency', function () {
+    $controller = new FleetOpsPaymentControllerProbe();
+    $payments   = [
+        (object) ['serviceQuote' => (object) ['currency' => 'USD', 'amount' => 100]],
+        (object) ['serviceQuote' => (object) ['currency' => 'USD', 'amount' => 25]],
+        (object) ['serviceQuote' => (object) ['currency' => 'SGD', 'amount' => 50]],
+    ];
+
+    expect($controller->callHelper('totalsByServiceQuoteCurrency', $payments))->toBe([
+        'USD' => 125,
+        'SGD' => 50,
+    ]);
+});
+
+test('payment controller reports Stripe Connect account status from the current company', function (?string $accountId, bool $expected) {
+    $controller          = new FleetOpsPaymentControllerProbe();
+    $controller->company = $accountId === '__missing__' ? null : new FleetOpsPaymentCompanyFake($accountId);
+
+    expect($controller->hasStripeConnectAccount())->toBe([
+        'json' => ['hasStripeConnectAccount' => $expected],
+    ]);
+})->with([
+    'valid account'    => ['acct_123', true],
+    'customer account' => ['cus_123', false],
+    'missing company'  => ['__missing__', false],
+]);
+
+test('payment controller creates Stripe accounts and stores the account id', function () {
+    $company             = new FleetOpsPaymentCompanyFake();
+    $controller          = new FleetOpsPaymentControllerProbe();
+    $controller->company = $company;
+    $controller->stripe  = new FleetOpsPaymentStripeFake();
+
+    expect($controller->getStripeAccount())->toBe([
+        'json' => ['account' => 'acct_created'],
+    ])
+        ->and($company->updates)->toBe([
+            ['stripe_connect_id' => 'acct_created'],
+        ])
+        ->and($controller->stripe->accounts->creates[0]['controller']['stripe_dashboard']['type'])->toBe('express')
+        ->and($controller->stripe->accounts->creates[0]['controller']['fees']['payer'])->toBe('application')
+        ->and($controller->stripe->accounts->creates[0]['controller']['losses']['payments'])->toBe('application');
+});
+
+test('payment controller returns Stripe account creation errors', function () {
+    $controller         = new FleetOpsPaymentControllerProbe();
+    $controller->stripe = new FleetOpsPaymentStripeFake(new Exception('stripe account failed'));
+
+    expect($controller->getStripeAccount())->toBe([
+        'error' => 'stripe account failed',
+    ]);
+});
+
+test('payment controller creates Stripe account sessions with request or company accounts', function (?string $requestAccount, string $expectedAccount) {
+    $controller          = new FleetOpsPaymentControllerProbe();
+    $controller->company = new FleetOpsPaymentCompanyFake('acct_company');
+    $controller->stripe  = new FleetOpsPaymentStripeFake();
+    $request             = new Illuminate\Http\Request(array_filter(['account' => $requestAccount]));
+
+    expect($controller->getStripeAccountSession($request))->toBe([
+        'json' => ['clientSecret' => 'session_secret'],
+    ])
+        ->and($controller->stripe->accountSessions->creates[0])->toBe([
+            'account'    => $expectedAccount,
+            'components' => [
+                'account_onboarding' => [
+                    'enabled' => true,
+                ],
+            ],
+        ]);
+})->with([
+    'request account' => ['acct_request', 'acct_request'],
+    'company account' => [null, 'acct_company'],
+]);
+
+test('payment controller returns Stripe account session errors', function () {
+    $controller          = new FleetOpsPaymentControllerProbe();
+    $controller->company = new FleetOpsPaymentCompanyFake('acct_company');
+    $controller->stripe  = new FleetOpsPaymentStripeFake(null, new Exception('stripe session failed'));
+
+    expect($controller->getStripeAccountSession(new Illuminate\Http\Request()))->toBe([
+        'error' => 'stripe session failed',
+    ]);
+});

package/server/tests/PointResolutionTest.php

@@ -39,6 +39,60 @@ test('point resolution rejects malformed feature points cleanly', function () {
     ]))->toThrow(Exception::class, 'Attempted to resolve Point from invalid location.');
 });
 
+test('point resolution falls back to nested geometry coordinates', function () {
+    // A geometry-typed envelope that also carries a nested `geometry` — the
+    // shape some upstream payloads produce when a Feature is flattened badly.
+    // The top-level coordinates are empty, so Point::fromJson fails and the
+    // resolution falls through to the nested pair rather than giving up.
+    $point = Utils::getPointFromMixed([
+        'type'        => 'Point',
+        'coordinates' => [],
+        'geometry'    => [
+            'type'        => 'Point',
+            'coordinates' => [103.851, 1.2816],
+        ],
+    ]);
+
+    // The nested pair is GeoJSON, so it is read as [lng, lat]
+    expect($point->getLat())->toBe(1.2816)
+        ->and($point->getLng())->toBe(103.851);
+});
+
+test('point resolution falls back to top level coordinates before nested geometry', function () {
+    // The top-level `coordinates` arm is preferred, and is read in the same
+    // GeoJSON order. Point::fromJson rejects the envelope because of the extra
+    // member, which is what pushes resolution into the fallback at all.
+    $point = Utils::getPointFromMixed([
+        'type'        => 'Point',
+        'coordinates' => [103.851, 1.2816],
+        'geometry'    => [
+            'type'        => 'Point',
+            'coordinates' => [1.0, 2.0],
+        ],
+    ]);
+
+    expect($point->getLat())->toBe(1.2816)
+        ->and($point->getLng())->toBe(103.851);
+});
+
+test('point resolution still hands nested rings to the positional reader', function () {
+    // A Polygon ring is not a coordinate pair, so the GeoJSON read declines and
+    // resolution falls through to the existing recursion unchanged.
+    $point = Utils::getPointFromMixed([
+        'type'        => 'Polygon',
+        'coordinates' => [
+            [
+                [103.0, 1.0],
+                [104.0, 1.0],
+                [104.0, 2.0],
+                [103.0, 1.0],
+            ],
+        ],
+    ]);
+
+    expect($point)->toBeInstanceOf(Fleetbase\LaravelMysqlSpatial\Types\Point::class);
+});
+
 test('coordinate helper does not collapse bbox GeoJSON point to zero', function () {
     $point = Utils::getPointFromCoordinates([
         'type'     => 'Feature',