@fleetbase/fleetops-engine 0.6.70 → 0.6.72

package/server/tests/NotificationAndMailContractsTest.php

@@ -370,8 +370,7 @@ test('order dispatch failed notification exposes channels array and mail payload
         ->and($mail->subject)->toBe('Order TN-FAILED dispatch has failed!')
         ->and($mail->introLines)->toBe(['No driver accepted the order'])
         ->and($mail->actionText)->toBe('Track Order')
-        ->and($mail->actionUrl)->toContain('track-order')
-        ->and($mail->actionUrl)->toContain('TN-FAILED');
+        ->and($mail->actionUrl)->toEndWith('/~/track/TN-FAILED');
 });
 
 test('order dispatched notification exposes channels array and mail payloads', function () {
@@ -449,8 +448,7 @@ test('order assigned notification handles scheduled and unscheduled contracts',
         ->and($mail->subject)->toBe('New order TN-ASSIGNED assigned!')
         ->and($mail->introLines)->toBe(['You have a new order assigned, tap for details.'])
         ->and($mail->actionText)->toBe('Track Order')
-        ->and($mail->actionUrl)->toContain('track-order')
-        ->and($mail->actionUrl)->toContain('TN-ASSIGNED');
+        ->and($mail->actionUrl)->toEndWith('/~/track/TN-ASSIGNED');
 
     $scheduledOrder      = notificationTestOrderWithRelations(['scheduled_at' => '2026-08-01 10:30:00']);
     $scheduled           = new OrderAssigned($scheduledOrder);
@@ -545,7 +543,7 @@ test('terminal order notifications expose shared broadcast and array payload con
             'event' => 'order.canceled_notification',
             'title' => 'Order WP-TRACK-123 was canceled',
             'body'  => 'Order WP-TRACK-123 has been canceled. customer requested cancel',
-            'data'  => ['id' => 'order_public', 'type' => 'order_canceled'],
+            'data'  => ['id' => 'order_public', 'type' => 'order_canceled', 'reason' => 'customer requested cancel'],
         ])
         ->and($failed->toArray())->toMatchArray([
             'event' => 'order.failed_notification',
@@ -599,8 +597,7 @@ test('waypoint completed notification exposes channels array and mail payloads',
             'No further action is necessary.',
         ])
         ->and($mail->actionText)->toBe('Track Order')
-        ->and($mail->actionUrl)->toContain('track-order')
-        ->and($mail->actionUrl)->toContain('WP-COMPLETE');
+        ->and($mail->actionUrl)->toEndWith('/~/track/WP-COMPLETE');
 });
 
 test('work order dispatched mail exposes subject and markdown context', function () {
@@ -704,5 +701,5 @@ test('customer credentials mail reads the portal slug from the customer company
 
     $content = fleetOpsNotificationWithEnvironment(fn () => (new CustomerCredentialsMail('plain-secret', $customer))->content());
 
-    expect($content->with['customerPortalUrl'])->toBe('https://console.fleetbase.test/acme-portal');
+    expect($content->with['customerPortalUrl'])->toBe('https://console.fleetbase.test/customer-access/acme-portal');
 })->with([null, 'other-company']);

package/server/tests/ObserverContractsTest.php

@@ -286,7 +286,7 @@ class FleetOpsVehicleObserverProbe extends VehicleObserver
         return $this->driver && $identifier === $this->identifier ? $this->driver : null;
     }
 
-    protected function deleteDriversAssignedTo(Vehicle $vehicle): mixed
+    protected function unassignDriversFrom(Vehicle $vehicle): int
     {
         $this->deleted[] = $vehicle->uuid;
 
@@ -397,11 +397,16 @@ class FleetOpsTrackingNumberObserverProbe extends TrackingNumberObserver
         return 'TN-' . $trackingNumber->region;
     }
 
-    protected function generateBarcode(string $ownerUuid, string $type): string
+    protected function generateCodeImages(string $trackingNumber, ?string $ownerPublicId): array
     {
-        $this->barcodes[] = [$ownerUuid, $type];
+        $this->barcodes[] = [$trackingNumber, $ownerPublicId];
 
-        return $type . '-png';
+        return ['qr_code' => 'qr-png', 'barcode' => 'barcode-png'];
+    }
+
+    protected function ownerPublicId(TrackingNumber $trackingNumber): ?string
+    {
+        return $trackingNumber->owner_uuid ? 'order_public' : null;
     }
 
     protected function createTrackingStatus(array $attributes): TrackingStatus
@@ -531,12 +536,12 @@ class FleetOpsCompanyUserObserverProbe extends CompanyUserObserver
     public array $deleted  = [];
     public ?Driver $driver = null;
 
-    protected function deleteDrivers(string $userUuid): void
+    protected function deleteDrivers(string $userUuid, ?string $companyUuid): void
     {
         $this->deleted[] = $userUuid;
     }
 
-    protected function findDriver(string $userUuid): ?Driver
+    protected function findDriver(string $userUuid, ?string $companyUuid): ?Driver
     {
         return $this->driver;
     }
@@ -1077,6 +1082,8 @@ test('order observer ignores non dispatched start transitions', function () {
 test('order observer invalidates cache on delete and forwards to integrated vendors', function () {
     Cache::swap(new Repository(new ArrayStore()));
     session(['company' => 'company-uuid']);
+    // Deleting cascades to the order's children, so the queries need a database.
+    Fleetbase\Tests\Support\TrackingPageDatabase::boot();
 
     $order       = new FleetOpsOrderObserverOrderFake();
     $order->uuid = 'order-deleted-uuid';
@@ -1095,6 +1102,8 @@ test('order observer invalidates cache on delete and forwards to integrated vend
     $integrated->integratedVendor = true;
 
     expect(fn () => (new OrderObserver())->deleted($integrated))->toThrow(Error::class);
+
+    Illuminate\Database\Eloquent\Model::unsetConnectionResolver();
 });
 
 test('contact observer creates syncs normalizes and deletes associated users', function () {
@@ -1292,11 +1301,12 @@ test('tracking number observer generates codes and creates initial tracking stat
     $observer->created($trackingNumber);
 
     expect($trackingNumber->tracking_number)->toBe('TN-sg')
-        ->and($trackingNumber->qr_code)->toBe('QRCODE-png')
-        ->and($trackingNumber->barcode)->toBe('PDF417-png')
+        ->and($trackingNumber->qr_code)->toBe('qr-png')
+        ->and($trackingNumber->barcode)->toBe('barcode-png')
+        // Codes are generated from the new tracking number and the owner's public id,
+        // never from the owner's uuid.
         ->and($observer->barcodes)->toBe([
-            ['owner-uuid', 'QRCODE'],
-            ['owner-uuid', 'PDF417'],
+            ['TN-sg', 'order_public'],
         ])
         ->and($observer->statuses[0])->toMatchArray([
             'company_uuid'         => 'company-uuid',
@@ -1309,6 +1319,58 @@ test('tracking number observer generates codes and creates initial tracking stat
         ->and($trackingNumber->ownerStatuses)->toHaveCount(1);
 });
 
+test('tracking number observer reads the owner public id and renders codes through the model', function () {
+    $observer = new TrackingNumberObserver();
+    $owner    = new ReflectionMethod($observer, 'ownerPublicId');
+    $images   = new ReflectionMethod($observer, 'generateCodeImages');
+    $owner->setAccessible(true);
+    $images->setAccessible(true);
+
+    // No owner: nothing to look up.
+    expect($owner->invoke($observer, new TrackingNumber()))->toBeNull();
+
+    $order = new Order();
+    $order->setRawAttributes(['uuid' => 'owner-uuid', 'public_id' => 'order_public'], true);
+    $trackingNumber = new TrackingNumber();
+    $trackingNumber->setRawAttributes(['owner_uuid' => 'owner-uuid', 'owner_type' => Order::class], true);
+    $trackingNumber->setRelation('owner', $order);
+
+    expect($owner->invoke($observer, $trackingNumber))->toBe('order_public');
+
+    // An owner without a public id yields none rather than an empty `r` parameter.
+    $order->setRawAttributes(['uuid' => 'owner-uuid', 'public_id' => ''], true);
+    expect($owner->invoke($observer, $trackingNumber))->toBeNull();
+
+    $previousConsole = config('fleetbase.console');
+    config(['fleetbase.console' => ['host' => 'console.fleetbase.test', 'secure' => true]]);
+    foreach (['DNS2D', 'DNS1D'] as $facade) {
+        app()->instance($facade, new class($facade) {
+            public function __construct(private string $facade)
+            {
+            }
+
+            public function getBarcodePNG($code, $type, ...$size)
+            {
+                return $this->facade . ':' . $type . ':' . $code;
+            }
+        });
+        Illuminate\Support\Facades\Facade::clearResolvedInstance($facade);
+    }
+
+    try {
+        expect($images->invoke($observer, 'TN-sg', 'order_public'))->toBe([
+            'qr_code' => 'DNS2D:QRCODE,M:https://console.fleetbase.test/~/track-order?order=TN-sg&r=order_public&v=1',
+            'barcode' => 'DNS1D:C128:TN-sg',
+        ]);
+    } finally {
+        config(['fleetbase.console' => $previousConsole]);
+        foreach (['DNS2D', 'DNS1D'] as $facade) {
+            app()->forgetInstance($facade);
+            Illuminate\Support\Facades\Facade::clearResolvedInstance($facade);
+        }
+    }
+});
+
 test('zone observer invalidates service area cache for lifecycle events and original service area', function () {
     $zone = new Zone();
     $zone->setRawAttributes([

package/server/tests/OrderActivityFlowRegressionTest.php

@@ -20,7 +20,8 @@ use Fleetbase\FleetOps\Models\Waypoint;
 use Fleetbase\FleetOps\Support\ResolvesOrderServiceStops;
 use Fleetbase\LaravelMysqlSpatial\Types\Point;
 
-class ActivityFlowRelationCountFake
+// Extends the relation the model method now declares, so the override stays compatible; the parent constructor is skipped on purpose.
+class ActivityFlowRelationCountFake extends Illuminate\Database\Eloquent\Relations\HasManyThrough
 {
     public function __construct(private int $count)
     {
@@ -67,7 +68,7 @@ class ActivityFlowPayloadFake extends Payload
         return $this;
     }
 
-    public function waypoints()
+    public function waypoints(): Illuminate\Database\Eloquent\Relations\HasManyThrough
     {
         return new ActivityFlowRelationCountFake($this->waypoints?->count() ?? 0);
     }

package/server/tests/OrderConfigLifecycleTest.php

@@ -0,0 +1,120 @@
+<?php
+
+use Fleetbase\FleetOps\Models\OrderConfig;
+
+/**
+ * Opt-in configured lifecycles (`meta.lifecycle`): a config can define its own initial, completed,
+ * canceled and terminal activities, disable dispatch and require configured transitions, without
+ * changing the default dispatch lifecycle of configs that do not opt in.
+ */
+function lifecycleActivity(string $code, array $children = [], bool $complete = false): array
+{
+    return ['key' => $code, 'code' => $code, 'status' => ucfirst(str_replace('_', ' ', $code)), 'details' => '', 'activities' => $children, 'logic' => [], 'events' => [], 'complete' => $complete];
+}
+
+function customLifecycleConfig(array $lifecycle = []): OrderConfig
+{
+    $config = new OrderConfig();
+    $config->setRawAttributes([
+        'flow' => json_encode([
+            'requested'   => lifecycleActivity('requested', ['assigned', 'cancelled']),
+            'assigned'    => lifecycleActivity('assigned', ['handed_over', 'cancelled']),
+            'handed_over' => lifecycleActivity('handed_over', ['active']),
+            'active'      => lifecycleActivity('active', ['extended', 'returned']),
+            'extended'    => lifecycleActivity('extended', ['active']),
+            'returned'    => lifecycleActivity('returned', ['completed']),
+            'completed'   => lifecycleActivity('completed', [], true),
+            'cancelled'   => lifecycleActivity('cancelled'),
+        ]),
+        'meta' => json_encode(['lifecycle' => array_replace([
+            'initial'            => 'requested',
+            'completed'          => 'completed',
+            'canceled'           => 'cancelled',
+            'terminal'           => ['completed', 'cancelled'],
+            'dispatch'           => false,
+            'strict_transitions' => true,
+        ], $lifecycle)]),
+    ]);
+
+    return $config;
+}
+
+function defaultLifecycleConfig(): OrderConfig
+{
+    $config = new OrderConfig();
+    $config->setRawAttributes([
+        'flow' => json_encode([
+            'created'    => lifecycleActivity('created', ['dispatched']),
+            'dispatched' => lifecycleActivity('dispatched', ['started']),
+            'started'    => lifecycleActivity('started', ['completed']),
+            'completed'  => lifecycleActivity('completed', [], true),
+        ]),
+        'meta' => json_encode([]),
+    ]);
+
+    return $config;
+}
+
+test('configs without meta.lifecycle keep the default dispatch semantics', function () {
+    $config = defaultLifecycleConfig();
+
+    expect($config->hasConfiguredLifecycle())->toBeFalse()
+        ->and($config->getInitialStatusCode())->toBe('created')
+        ->and($config->allowsDispatch())->toBeTrue()
+        ->and($config->hasStrictTransitions())->toBeFalse()
+        ->and($config->getTerminalActivityCodes())->toBe(['completed', 'canceled'])
+        ->and($config->getCanceledActivity()->code)->toBe('canceled')
+        ->and($config->getInitialActivity()->code)->toBe('created');
+});
+
+test('a configured lifecycle names its own initial, cancel and completion activities', function () {
+    $config = customLifecycleConfig();
+
+    expect($config->hasConfiguredLifecycle())->toBeTrue()
+        ->and($config->getInitialStatusCode())->toBe('requested')
+        ->and($config->getInitialActivity()->code)->toBe('requested')
+        ->and($config->getCanceledActivity()->code)->toBe('cancelled')
+        ->and($config->getCompletedActivity()->code)->toBe('completed')
+        ->and($config->allowsDispatch())->toBeFalse()
+        ->and($config->hasStrictTransitions())->toBeTrue()
+        ->and($config->isTerminalActivityCode('cancelled'))->toBeTrue()
+        ->and($config->isTerminalActivityCode('canceled'))->toBeFalse();
+});
+
+test('transitions follow only the configured graph', function () {
+    $config = customLifecycleConfig();
+
+    expect($config->canTransition('requested', 'assigned'))->toBeTrue()
+        ->and($config->canTransition('handed_over', 'active'))->toBeTrue()
+        ->and($config->canTransition('active', 'extended'))->toBeTrue()
+        ->and($config->canTransition('extended', 'active'))->toBeTrue()
+        ->and($config->canTransition('returned', 'completed'))->toBeTrue()
+        // skipped or foreign steps
+        ->and($config->canTransition('requested', 'handed_over'))->toBeFalse()
+        ->and($config->canTransition('requested', 'dispatched'))->toBeFalse()
+        ->and($config->canTransition('active', 'cancelled'))->toBeFalse()
+        // terminal and unknown sources
+        ->and($config->canTransition('completed', 'requested'))->toBeFalse()
+        ->and($config->canTransition('cancelled', 'assigned'))->toBeFalse()
+        ->and($config->canTransition(null, 'requested'))->toBeFalse()
+        ->and($config->canTransition('nope', 'assigned'))->toBeFalse();
+});
+
+test('a configuration-only change (added activity) is honoured without code changes', function () {
+    $config = customLifecycleConfig();
+    $flow   = json_decode($config->getAttributes()['flow'], true);
+    $flow['active']['activities'][] = 'inspection';
+    $flow['inspection']             = lifecycleActivity('inspection', ['returned']);
+    $config->setRawAttributes(['flow' => json_encode($flow), 'meta' => $config->getAttributes()['meta']]);
+
+    expect($config->canTransition('active', 'inspection'))->toBeTrue()
+        ->and($config->canTransition('inspection', 'returned'))->toBeTrue()
+        ->and($config->canTransition('inspection', 'completed'))->toBeFalse();
+});
+
+test('dispatch can be disabled with string or numeric falsy values', function () {
+    foreach ([false, 'false', 0, '0'] as $value) {
+        expect(customLifecycleConfig(['dispatch' => $value])->allowsDispatch())->toBeFalse();
+    }
+    expect(customLifecycleConfig(['dispatch' => true])->allowsDispatch())->toBeTrue();
+});

package/server/tests/OrderFilterExecutionTest.php

@@ -124,6 +124,173 @@ function fleetopsOrderFilter(FleetOpsRecordingOrderFilterBuilder $builder, array
     return $filter;
 }
 
+/**
+ * A filter whose request resolves to an internal console route.
+ *
+ * `Http::isInternalRequest()` reads the resolved route's uri, so the console's
+ * uuid pass-through is only reachable through a route resolver.
+ */
+function fleetopsInternalOrderFilter(FleetOpsRecordingOrderFilterBuilder $builder): OrderFilter
+{
+    $uri     = 'int/v1/fleet-ops/orders';
+    $request = Request::create('/' . $uri, 'GET');
+    $session = app('session.store');
+    $session->put('company', 'company_test');
+    $request->setLaravelSession($session);
+    $request->setRouteResolver(fn () => new class($uri) {
+        public array $action = [];
+
+        public function __construct(private string $uri)
+        {
+        }
+
+        public function uri(): string
+        {
+            return $this->uri;
+        }
+    });
+
+    $filter     = new OrderFilter($request);
+    $reflection = new ReflectionClass($filter);
+    $property   = $reflection->getParentClass()->getProperty('builder');
+    $property->setAccessible(true);
+    $property->setValue($filter, $builder);
+
+    return $filter;
+}
+
+/**
+ * Customer and facilitator filters resolve public ids to uuids, which is a real query.
+ *
+ * @return array<string, array<string, string>>
+ */
+function fleetopsOrderFilterRelationDatabase(): array
+{
+    $connection = new Illuminate\Database\SQLiteConnection(new PDO('sqlite::memory:'));
+    $resolver   = new Illuminate\Database\ConnectionResolver(['default' => $connection, 'mysql' => $connection]);
+    $resolver->setDefaultConnection('mysql');
+    Illuminate\Database\Eloquent\Model::setConnectionResolver($resolver);
+    app()->instance('db', new class($connection) {
+        public function __construct(public Illuminate\Database\SQLiteConnection $c)
+        {
+        }
+
+        public function connection($name = null)
+        {
+            return $this->c;
+        }
+
+        public function __call($method, $arguments)
+        {
+            return $this->c->{$method}(...$arguments);
+        }
+    });
+    Illuminate\Support\Facades\DB::clearResolvedInstance('db');
+
+    $schema = $connection->getSchemaBuilder();
+    foreach (['vendors', 'integrated_vendors', 'contacts'] as $table) {
+        $schema->create($table, function ($blueprint) {
+            $blueprint->increments('id');
+            foreach (['uuid', 'public_id', 'internal_id', 'company_uuid', 'name', '_key'] as $column) {
+                $blueprint->string($column)->nullable();
+            }
+            $blueprint->timestamps();
+            $blueprint->timestamp('deleted_at')->nullable();
+        });
+    }
+
+    $rows = [
+        'vendors'            => ['uuid' => '77777777-7777-4777-8777-777777777701', 'public_id' => 'vendor_ofilterone', 'internal_id' => 'VND-1'],
+        'integrated_vendors' => ['uuid' => '77777777-7777-4777-8777-777777777702', 'public_id' => 'integrated_vendor_ofilter'],
+        'contacts'           => ['uuid' => '77777777-7777-4777-8777-777777777703', 'public_id' => 'contact_ofilterone'],
+    ];
+
+    foreach ($rows as $table => $row) {
+        $connection->table($table)->insert($row + ['company_uuid' => 'company_test']);
+    }
+
+    // Another tenant's vendor is never reachable by its public id.
+    $connection->table('vendors')->insert(['uuid' => '77777777-7777-4777-8777-777777777709', 'public_id' => 'vendor_otherco', 'company_uuid' => 'another-company']);
+
+    return $rows;
+}
+
+/**
+ * @return array<int, array<int, string>>
+ */
+function fleetopsOrderFilterWhereInValues(FleetOpsRecordingOrderFilterBuilder $builder, string $column): array
+{
+    return collect($builder->methodCalls('whereIn'))
+        ->filter(fn ($call) => $call[1] === $column)
+        ->map(fn ($call) => $call[2])
+        ->values()
+        ->all();
+}
+
+test('order filter resolves facilitator public ids across vendors integrated vendors and contacts', function () {
+    $rows    = fleetopsOrderFilterRelationDatabase();
+    $builder = new FleetOpsRecordingOrderFilterBuilder();
+    $filter  = fleetopsOrderFilter($builder);
+
+    $filter->facilitator($rows['vendors']['public_id']);
+    $filter->facilitator($rows['vendors']['internal_id']);
+    $filter->facilitator($rows['integrated_vendors']['public_id']);
+    $filter->facilitator($rows['contacts']['public_id']);
+    // The public API never accepts a raw uuid, an unknown id, or another tenant's id.
+    $filter->facilitator($rows['vendors']['uuid']);
+    $filter->facilitator('vendor_missing');
+    $filter->facilitator('vendor_otherco');
+
+    // The filter used to compare the public id against `facilitator_uuid`
+    // directly, which could never match. An id that resolves to nothing now
+    // yields an empty list, so it matches no order rather than every order.
+    expect(fleetopsOrderFilterWhereInValues($builder, 'facilitator_uuid'))->toBe([
+        [$rows['vendors']['uuid']],
+        [$rows['vendors']['uuid']],
+        [$rows['integrated_vendors']['uuid']],
+        [$rows['contacts']['uuid']],
+        [],
+        [],
+        [],
+    ]);
+});
+
+test('order filter resolves customer public ids and keeps the customer portal user match', function () {
+    $rows    = fleetopsOrderFilterRelationDatabase();
+    $builder = new FleetOpsRecordingOrderFilterBuilder();
+    $filter  = fleetopsOrderFilter($builder);
+
+    $filter->customer($rows['contacts']['public_id']);
+    $filter->customer($rows['vendors']['public_id']);
+    $filter->customer('portal-user-uuid');
+
+    $userMatches = collect($builder->methodCalls('orWhereHas'))
+        ->filter(fn ($call) => $call[1] === 'authenticatableCustomer')
+        ->map(fn ($call) => $call[2]->calls)
+        ->values()
+        ->all();
+
+    expect(fleetopsOrderFilterWhereInValues($builder, 'customer_uuid'))->toBe([
+        [$rows['contacts']['uuid']],
+        [$rows['vendors']['uuid']],
+        [],
+    ])
+        // A customer portal user still reaches their orders by user uuid.
+        ->and($userMatches[2])->toBe([['where', 'user_uuid', ['portal-user-uuid']]]);
+});
+
+test('order filter keeps console uuids working for customer and facilitator', function () {
+    $rows    = fleetopsOrderFilterRelationDatabase();
+    $builder = new FleetOpsRecordingOrderFilterBuilder();
+    $filter  = fleetopsInternalOrderFilter($builder);
+
+    $filter->customer($rows['contacts']['uuid']);
+    $filter->facilitator($rows['integrated_vendors']['uuid']);
+
+    expect(fleetopsOrderFilterWhereInValues($builder, 'customer_uuid'))->toBe([[$rows['contacts']['uuid']]])
+        ->and(fleetopsOrderFilterWhereInValues($builder, 'facilitator_uuid'))->toBe([[$rows['integrated_vendors']['uuid']]]);
+});
+
 test('order filter applies internal and public base scopes with eager loading', function () {
     $builder = new FleetOpsRecordingOrderFilterBuilder();
     $filter  = fleetopsOrderFilter($builder);
@@ -161,9 +328,7 @@ test('order filter identity and relation filters support uuid and public identif
 
     $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);

package/server/tests/ProcessAllocationJobContractsTest.php

@@ -222,3 +222,23 @@ test('process allocation job commits assignments and skips missing or already as
             '[ProcessAllocationJob] Committed 4 assignments, 1 unassigned for company company-assign.',
         ]);
 });
+
+test('process allocation job logs when the selected engine was replaced by the fallback', function () {
+    $fallback = new class(['assignments' => [], 'unassigned' => ['order_one'], 'summary' => []]) extends FleetOpsProcessAllocationEngineFake {
+        public function getIdentifier(): string
+        {
+            return 'greedy';
+        }
+    };
+
+    $job           = new FleetOpsProcessAllocationJobProbe('company-fallback');
+    $job->engine   = 'vroom';
+    $job->orders   = collect([fleetOpsProcessAllocationOrder('order_one')]);
+    $job->vehicles = collect([(object) ['public_id' => 'vehicle_one']]);
+
+    $job->handle(fleetOpsProcessAllocationRegistry($fallback));
+
+    expect($fallback->calls)->toHaveCount(1)
+        ->and($job->messages[0])->toBe('[ProcessAllocationJob] Used the greedy engine instead of vroom for company company-fallback: No orchestration engine registered with identifier \'vroom\'. Available engines: greedy')
+        ->and($job->messages[1])->toContain('Committed 0 assignments, 1 unassigned');
+});