@fleetbase/fleetops-engine 0.6.58 → 0.6.59

package/server/tests/ProcessAllocationJobContractsTest.php

@@ -0,0 +1,224 @@
+<?php
+
+use Fleetbase\FleetOps\Jobs\ProcessAllocationJob;
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Orchestration\Contracts\OrchestrationEngineInterface;
+use Fleetbase\FleetOps\Orchestration\OrchestrationEngineRegistry;
+use Illuminate\Support\Collection;
+
+class FleetOpsProcessAllocationEngineFake implements OrchestrationEngineInterface
+{
+    public array $calls = [];
+
+    public function __construct(private array $result)
+    {
+    }
+
+    public function allocate(Collection $orders, Collection $vehicles, array $options = []): array
+    {
+        $this->calls[] = [$orders, $vehicles, $options];
+
+        return $this->result;
+    }
+
+    public function getName(): string
+    {
+        return 'Allocation Fake';
+    }
+
+    public function getIdentifier(): string
+    {
+        return 'fake';
+    }
+}
+
+class FleetOpsProcessAllocationJobProbe extends ProcessAllocationJob
+{
+    public Collection $orders;
+    public Collection $vehicles;
+    public array $ordersByPublicId  = [];
+    public array $driversByPublicId = [];
+    public array $messages          = [];
+    public string $engine           = 'fake';
+    public array $options           = [
+        'max_travel_time'  => 900,
+        'balance_workload' => true,
+    ];
+
+    public function __construct(string $companyUuid = 'company-uuid', array $orderIds = [])
+    {
+        parent::__construct($companyUuid, $orderIds);
+
+        $this->orders   = collect();
+        $this->vehicles = collect();
+    }
+
+    protected function unassignedOrders()
+    {
+        return $this->orders;
+    }
+
+    protected function availableVehicles()
+    {
+        return $this->vehicles;
+    }
+
+    protected function engineId(): string
+    {
+        return $this->engine;
+    }
+
+    protected function allocationOptions(): array
+    {
+        return $this->options;
+    }
+
+    protected function findOrderByPublicId(string $publicId): ?Order
+    {
+        return $this->ordersByPublicId[$publicId] ?? null;
+    }
+
+    protected function findDriverByPublicId(string $publicId): ?Driver
+    {
+        return $this->driversByPublicId[$publicId] ?? null;
+    }
+
+    protected function logInfo(string $message): void
+    {
+        $this->messages[] = $message;
+    }
+}
+
+class FleetOpsProcessAllocationOrderFake extends Order
+{
+    public bool $saved           = false;
+    public bool $firstDispatched = false;
+
+    public function save(array $options = []): bool
+    {
+        $this->saved = true;
+
+        return true;
+    }
+
+    public function firstDispatchWithActivity(): Order
+    {
+        $this->firstDispatched = true;
+
+        return $this;
+    }
+}
+
+function fleetOpsProcessAllocationOrder(string $publicId, ?string $assignedDriverUuid = null): FleetOpsProcessAllocationOrderFake
+{
+    $order = new FleetOpsProcessAllocationOrderFake();
+    $order->forceFill([
+        'public_id'            => $publicId,
+        'driver_assigned_uuid' => $assignedDriverUuid,
+    ]);
+
+    return $order;
+}
+
+function fleetOpsProcessAllocationDriver(string $publicId, string $uuid): Driver
+{
+    $driver = new Driver();
+    $driver->forceFill([
+        'public_id' => $publicId,
+        'uuid'      => $uuid,
+    ]);
+
+    return $driver;
+}
+
+function fleetOpsProcessAllocationRegistry(FleetOpsProcessAllocationEngineFake $engine): OrchestrationEngineRegistry
+{
+    $registry = new OrchestrationEngineRegistry();
+    $registry->register($engine);
+
+    return $registry;
+}
+
+test('process allocation job exits when there are no unassigned orders', function () {
+    $engine = new FleetOpsProcessAllocationEngineFake([
+        'assignments' => [],
+        'unassigned'  => [],
+        'summary'     => [],
+    ]);
+    $job = new FleetOpsProcessAllocationJobProbe('company-empty');
+
+    $job->handle(fleetOpsProcessAllocationRegistry($engine));
+
+    expect($engine->calls)->toBe([])
+        ->and($job->messages)->toBe([
+            '[ProcessAllocationJob] No unassigned orders for company company-empty.',
+        ]);
+});
+
+test('process allocation job exits when there are no available vehicles', function () {
+    $engine = new FleetOpsProcessAllocationEngineFake([
+        'assignments' => [],
+        'unassigned'  => [],
+        'summary'     => [],
+    ]);
+    $job         = new FleetOpsProcessAllocationJobProbe('company-no-vehicles');
+    $job->orders = collect([fleetOpsProcessAllocationOrder('order_one')]);
+
+    $job->handle(fleetOpsProcessAllocationRegistry($engine));
+
+    expect($engine->calls)->toBe([])
+        ->and($job->messages)->toBe([
+            '[ProcessAllocationJob] No available vehicles for company company-no-vehicles.',
+        ]);
+});
+
+test('process allocation job commits assignments and skips missing or already assigned records', function () {
+    $engine = new FleetOpsProcessAllocationEngineFake([
+        'assignments' => [
+            ['order_id' => 'order_one', 'driver_id' => 'driver_one', 'vehicle_id' => 'vehicle_one', 'sequence' => 1],
+            ['order_id' => 'missing_order', 'driver_id' => 'driver_one', 'vehicle_id' => 'vehicle_one', 'sequence' => 1],
+            ['order_id' => 'order_two', 'driver_id' => 'missing_driver', 'vehicle_id' => 'vehicle_one', 'sequence' => 1],
+            ['order_id' => 'order_three', 'driver_id' => 'driver_two', 'vehicle_id' => 'vehicle_two', 'sequence' => 1],
+        ],
+        'unassigned' => ['order_four'],
+        'summary'    => ['engine' => 'fake'],
+    ]);
+
+    $orderOne   = fleetOpsProcessAllocationOrder('order_one');
+    $orderTwo   = fleetOpsProcessAllocationOrder('order_two');
+    $orderThree = fleetOpsProcessAllocationOrder('order_three', 'already-driver');
+    $driverOne  = fleetOpsProcessAllocationDriver('driver_one', 'driver-uuid-one');
+    $driverTwo  = fleetOpsProcessAllocationDriver('driver_two', 'driver-uuid-two');
+
+    $job                   = new FleetOpsProcessAllocationJobProbe('company-assign');
+    $job->orders           = collect([$orderOne, $orderTwo, $orderThree]);
+    $job->vehicles         = collect([(object) ['public_id' => 'vehicle_one']]);
+    $job->ordersByPublicId = [
+        'order_one'   => $orderOne,
+        'order_two'   => $orderTwo,
+        'order_three' => $orderThree,
+    ];
+    $job->driversByPublicId = [
+        'driver_one' => $driverOne,
+        'driver_two' => $driverTwo,
+    ];
+
+    $job->handle(fleetOpsProcessAllocationRegistry($engine));
+
+    expect($engine->calls)->toHaveCount(1)
+        ->and($engine->calls[0][0])->toBe($job->orders)
+        ->and($engine->calls[0][1])->toBe($job->vehicles)
+        ->and($engine->calls[0][2])->toBe([
+            'max_travel_time'  => 900,
+            'balance_workload' => true,
+        ])
+        ->and($orderOne->driver_assigned_uuid)->toBe('driver-uuid-one')
+        ->and($orderOne->saved)->toBeTrue()
+        ->and($orderOne->firstDispatched)->toBeTrue()
+        ->and($orderTwo->saved)->toBeFalse()
+        ->and($orderThree->saved)->toBeFalse()
+        ->and($job->messages)->toBe([
+            '[ProcessAllocationJob] Committed 4 assignments, 1 unassigned for company company-assign.',
+        ]);
+});

package/server/tests/ProofAndSensorControllerContractsTest.php

@@ -0,0 +1,44 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Controllers\Api\v1\SensorController;
+use Fleetbase\LaravelMysqlSpatial\Types\Point;
+use Illuminate\Http\Request;
+
+class FleetOpsSensorControllerProbe extends SensorController
+{
+    public function callInput(Request $request): array
+    {
+        return $this->input($request);
+    }
+}
+
+test('api sensor controller input maps positions and blank sensorable assignments', function () {
+    $controller = new FleetOpsSensorControllerProbe();
+
+    $withCoordinates = $controller->callInput(new Request([
+        'name'                => 'Fuel Tank',
+        'type'                => 'fuel',
+        'latitude'            => '1.3521',
+        'longitude'           => '103.8198',
+        'threshold_inclusive' => true,
+        'sensorable'          => '',
+        'sensorable_type'     => 'fleet-ops:vehicle',
+    ]));
+
+    expect($withCoordinates['name'])->toBe('Fuel Tank')
+        ->and($withCoordinates['type'])->toBe('fuel')
+        ->and($withCoordinates['threshold_inclusive'])->toBeTrue()
+        ->and($withCoordinates['last_position'])->toBeInstanceOf(Point::class)
+        ->and($withCoordinates['last_position']->getLat())->toBe(1.3521)
+        ->and($withCoordinates['last_position']->getLng())->toBe(103.8198)
+        ->and($withCoordinates['sensorable_type'])->toBeNull()
+        ->and($withCoordinates['sensorable_uuid'])->toBeNull();
+
+    $withPositionArray = $controller->callInput(new Request([
+        'last_position' => [103.82, 1.36],
+    ]));
+
+    expect($withPositionArray['last_position'])->toBeInstanceOf(Point::class)
+        ->and($withPositionArray['last_position']->getLat())->toBe(103.82)
+        ->and($withPositionArray['last_position']->getLng())->toBe(1.36);
+});

package/server/tests/ProviderContractsTest.php

@@ -0,0 +1,409 @@
+<?php
+
+use Fleetbase\Events\ScheduleItemCreated;
+use Fleetbase\Events\ScheduleItemUpdated;
+use Fleetbase\Events\UserRemovedFromCompany;
+use Fleetbase\FleetOps\Console\Commands\DispatchOrders;
+use Fleetbase\FleetOps\Console\Commands\ProcessOperationalAlerts;
+use Fleetbase\FleetOps\Console\Commands\SyncTelematics;
+use Fleetbase\FleetOps\Events\GeofenceDwelled;
+use Fleetbase\FleetOps\Events\GeofenceEntered;
+use Fleetbase\FleetOps\Events\GeofenceExited;
+use Fleetbase\FleetOps\Events\OrderCompleted;
+use Fleetbase\FleetOps\Events\OrderDispatched;
+use Fleetbase\FleetOps\Listeners\HandleDeliveryCompletion;
+use Fleetbase\FleetOps\Listeners\HandleGeofenceDwelled;
+use Fleetbase\FleetOps\Listeners\HandleGeofenceEntered;
+use Fleetbase\FleetOps\Listeners\HandleGeofenceExited;
+use Fleetbase\FleetOps\Listeners\HandleOrderDispatched;
+use Fleetbase\FleetOps\Listeners\HandleUserRemovedFromCompany;
+use Fleetbase\FleetOps\Listeners\NotifyDriverOnShiftChange;
+use Fleetbase\FleetOps\Listeners\NotifyOrderEvent;
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\Fleet;
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Models\Payload;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Notifications\LateDeparture;
+use Fleetbase\FleetOps\Notifications\OrderAssigned;
+use Fleetbase\FleetOps\Notifications\OrderCompleted as OrderCompletedNotification;
+use Fleetbase\FleetOps\Notifications\OrderDispatched as OrderDispatchedNotification;
+use Fleetbase\FleetOps\Notifications\OrderDispatchFailed;
+use Fleetbase\FleetOps\Notifications\OrderPing;
+use Fleetbase\FleetOps\Notifications\ProlongedStoppage;
+use Fleetbase\FleetOps\Notifications\RouteDeviation;
+use Fleetbase\FleetOps\Observers\DriverObserver;
+use Fleetbase\FleetOps\Observers\FleetObserver;
+use Fleetbase\FleetOps\Observers\OrderObserver;
+use Fleetbase\FleetOps\Observers\PayloadObserver;
+use Fleetbase\FleetOps\Observers\VehicleObserver;
+use Fleetbase\FleetOps\Orchestration\OrchestrationEngineRegistry;
+use Fleetbase\FleetOps\Providers\FleetOpsServiceProvider;
+use Fleetbase\FleetOps\Providers\NotificationServiceProvider;
+use Fleetbase\FleetOps\Providers\ReportSchemaServiceProvider;
+use Fleetbase\FleetOps\Support\FuelProviders\FuelProviderRegistry;
+use Fleetbase\FleetOps\Support\GeofenceIntersectionService;
+use Fleetbase\FleetOps\Tracking\TrackingProviderRegistry;
+use Fleetbase\Listeners\SendResourceLifecycleWebhook;
+use Fleetbase\Providers\CoreServiceProvider;
+use Fleetbase\Support\NotificationRegistry;
+use Fleetbase\Support\Reporting\ReportSchemaRegistry;
+
+function providerDefaultProperty(string $class, string $property): mixed
+{
+    return (new ReflectionClass($class))->getDefaultProperties()[$property];
+}
+
+class FleetOpsProviderContractsAppFake
+{
+    public array $registeredProviders     = [];
+    public array $singletons              = [];
+    public array $resolvingCallbacks      = [];
+    public array $afterResolvingCallbacks = [];
+
+    public function register(string $provider): void
+    {
+        $this->registeredProviders[] = $provider;
+    }
+
+    public function singleton(string $abstract, callable $callback): void
+    {
+        $this->singletons[$abstract] = $callback;
+    }
+
+    public function resolving(string $abstract, callable $callback): void
+    {
+        $this->resolvingCallbacks[$abstract][] = $callback;
+    }
+
+    public function afterResolving(string $abstract, callable $callback): void
+    {
+        $this->afterResolvingCallbacks[$abstract][] = $callback;
+    }
+
+    public function resolved(string $abstract): bool
+    {
+        return false;
+    }
+
+    public function make(string $abstract): never
+    {
+        throw new RuntimeException("Unexpected make call for {$abstract}");
+    }
+}
+
+class FleetOpsProviderContractsScheduledEventFake
+{
+    public array $methods = [];
+
+    public function __construct(public string $command)
+    {
+    }
+
+    public function everyMinute(): self
+    {
+        $this->methods[] = ['everyMinute'];
+
+        return $this;
+    }
+
+    public function everyTenMinutes(): self
+    {
+        $this->methods[] = ['everyTenMinutes'];
+
+        return $this;
+    }
+
+    public function daily(): self
+    {
+        $this->methods[] = ['daily'];
+
+        return $this;
+    }
+
+    public function withoutOverlapping(): self
+    {
+        $this->methods[] = ['withoutOverlapping'];
+
+        return $this;
+    }
+
+    public function storeOutputInDb(): self
+    {
+        $this->methods[] = ['storeOutputInDb'];
+
+        return $this;
+    }
+}
+
+class FleetOpsProviderContractsScheduleFake
+{
+    public array $commands = [];
+
+    public function command(string $command): FleetOpsProviderContractsScheduledEventFake
+    {
+        $event                    = new FleetOpsProviderContractsScheduledEventFake($command);
+        $this->commands[$command] = $event;
+
+        return $event;
+    }
+}
+
+class FleetOpsProviderContractsProviderProbe extends FleetOpsServiceProvider
+{
+    public array $calls                                     = [];
+    public ?FleetOpsProviderContractsScheduleFake $schedule = null;
+
+    public function registerObservers(): void
+    {
+        $this->calls[] = ['registerObservers'];
+    }
+
+    public function registerCommands(): void
+    {
+        $this->calls[] = ['registerCommands'];
+    }
+
+    public function scheduleCommands(?callable $callback = null): void
+    {
+        $this->calls[]  = ['scheduleCommands'];
+        $this->schedule = new FleetOpsProviderContractsScheduleFake();
+        $callback($this->schedule);
+    }
+
+    public function registerExpansionsFrom($from = null, $namespace = null): void
+    {
+        $this->calls[] = ['registerExpansionsFrom', $from, $namespace];
+    }
+
+    protected function loadRoutesFrom($path)
+    {
+        $this->calls[] = ['loadRoutesFrom', $path];
+    }
+
+    protected function loadMigrationsFrom($paths)
+    {
+        $this->calls[] = ['loadMigrationsFrom', $paths];
+    }
+
+    protected function loadViewsFrom($path, $namespace)
+    {
+        $this->calls[] = ['loadViewsFrom', $path, $namespace];
+    }
+
+    protected function mergeConfigFrom($path, $key)
+    {
+        $this->calls[] = ['mergeConfigFrom', $path, $key];
+    }
+}
+
+test('fleetops service provider declares core observers and commands', function () {
+    $observers = providerDefaultProperty(FleetOpsServiceProvider::class, 'observers');
+    $commands  = providerDefaultProperty(FleetOpsServiceProvider::class, 'commands');
+
+    expect($observers)->toMatchArray([
+        Order::class   => OrderObserver::class,
+        Payload::class => PayloadObserver::class,
+        Driver::class  => DriverObserver::class,
+        Vehicle::class => VehicleObserver::class,
+        Fleet::class   => FleetObserver::class,
+    ])
+        ->and($commands)->toContain(
+            DispatchOrders::class,
+            ProcessOperationalAlerts::class,
+            SyncTelematics::class
+        );
+});
+
+test('fleetops service provider executes package registration and boot wiring', function () {
+    $originalNotifications = NotificationRegistry::$notifications;
+    $originalNotifiables   = NotificationRegistry::$notifiables;
+
+    try {
+        NotificationRegistry::$notifications = [];
+        NotificationRegistry::$notifiables   = [];
+
+        $app      = new FleetOpsProviderContractsAppFake();
+        $provider = new FleetOpsProviderContractsProviderProbe($app);
+
+        $provider->register();
+
+        expect($app->registeredProviders)->toBe([
+            CoreServiceProvider::class,
+            ReportSchemaServiceProvider::class,
+        ])
+            ->and(array_keys($app->singletons))->toBe([
+                GeofenceIntersectionService::class,
+                OrchestrationEngineRegistry::class,
+                TrackingProviderRegistry::class,
+                FuelProviderRegistry::class,
+            ])
+            ->and(($app->singletons[GeofenceIntersectionService::class])())->toBeInstanceOf(GeofenceIntersectionService::class)
+            ->and(($app->singletons[OrchestrationEngineRegistry::class])())->toBeInstanceOf(OrchestrationEngineRegistry::class)
+            ->and(($app->singletons[TrackingProviderRegistry::class])())->toBeInstanceOf(TrackingProviderRegistry::class)
+            ->and(($app->singletons[FuelProviderRegistry::class])())->toBeInstanceOf(FuelProviderRegistry::class);
+
+        $provider->boot();
+
+        $orchestrationRegistry = new OrchestrationEngineRegistry();
+        foreach ($app->resolvingCallbacks[OrchestrationEngineRegistry::class] as $callback) {
+            $callback($orchestrationRegistry);
+        }
+
+        $trackingRegistry = new TrackingProviderRegistry();
+        foreach ($app->resolvingCallbacks[TrackingProviderRegistry::class] as $callback) {
+            $callback($trackingRegistry);
+        }
+
+        expect($provider->calls)->toContain(
+            ['registerObservers'],
+            ['registerCommands'],
+            ['scheduleCommands'],
+            ['loadRoutesFrom', dirname(__DIR__) . '/src/Providers/../routes.php'],
+            ['loadMigrationsFrom', dirname(__DIR__) . '/src/Providers/../../migrations'],
+            ['loadViewsFrom', dirname(__DIR__) . '/src/Providers/../../resources/views', 'fleetops'],
+            ['mergeConfigFrom', dirname(__DIR__) . '/src/Providers/../../config/fleetops.php', 'fleetops'],
+            ['mergeConfigFrom', dirname(__DIR__) . '/src/Providers/../../config/geocoder.php', 'geocoder']
+        )
+            ->and($provider->schedule?->commands)->toHaveKeys([
+                'fleetops:dispatch-orders',
+                'fleetops:dispatch-adhoc',
+                'fleetops:update-estimations',
+                'fleetops:purge-service-quotes',
+                'fleetops:process-maintenance-triggers',
+                'fleetops:send-maintenance-reminders',
+                'fleetops:process-operational-alerts',
+                'fleetops:sync-telematics',
+            ])
+            ->and($provider->schedule?->commands['fleetops:dispatch-orders']->methods)->toContain(['everyMinute'], ['withoutOverlapping'], ['storeOutputInDb'])
+            ->and($provider->schedule?->commands['fleetops:update-estimations']->methods)->toContain(['everyTenMinutes'], ['withoutOverlapping'])
+            ->and($orchestrationRegistry->has('vroom'))->toBeTrue()
+            ->and($orchestrationRegistry->has('greedy'))->toBeTrue()
+            ->and($orchestrationRegistry->has('capacity'))->toBeTrue()
+            ->and($trackingRegistry->has('google_routes'))->toBeTrue()
+            ->and($trackingRegistry->has('osrm'))->toBeTrue()
+            ->and($trackingRegistry->has('calculated'))->toBeTrue()
+            ->and(collect(NotificationRegistry::$notifications)->pluck('definition')->all())->toContain(
+                OrderAssigned::class,
+                OrderDispatchFailed::class,
+                LateDeparture::class,
+                RouteDeviation::class,
+                ProlongedStoppage::class
+            )
+            ->and(NotificationRegistry::$notifiables)->toContain(
+                Fleetbase\FleetOps\Models\Contact::class,
+                Driver::class,
+                Fleetbase\FleetOps\Models\Vendor::class,
+                Fleet::class,
+                'dynamic:customer',
+                'dynamic:driver',
+                'dynamic:facilitator'
+            );
+    } finally {
+        NotificationRegistry::$notifications = $originalNotifications;
+        NotificationRegistry::$notifiables   = $originalNotifiables;
+    }
+});
+
+test('report schema service provider registers fleetops tables after registry resolution', function () {
+    $app      = new FleetOpsProviderContractsAppFake();
+    $provider = new ReportSchemaServiceProvider($app);
+
+    $provider->register();
+
+    $registry = new ReportSchemaRegistry();
+    foreach ($app->afterResolvingCallbacks[ReportSchemaRegistry::class] as $callback) {
+        $callback($registry);
+    }
+
+    expect($registry->getRegisteredTableNames())->toContain(
+        'orders',
+        'drivers',
+        'vehicles',
+        'places',
+        'contacts',
+        'vendors',
+        'fuel_reports'
+    );
+});
+
+test('fleetops service provider notification registry list includes operational alerts', function () {
+    $method = new ReflectionMethod(FleetOpsServiceProvider::class, 'registerNotifications');
+    $source = file($method->getFileName());
+    $body   = implode('', array_slice($source, $method->getStartLine() - 1, $method->getEndLine() - $method->getStartLine() + 1));
+
+    expect($body)->toContain(
+        OrderAssigned::class,
+        OrderCompletedNotification::class,
+        OrderPing::class,
+        LateDeparture::class,
+        RouteDeviation::class,
+        ProlongedStoppage::class
+    )
+        ->and($body)->toContain(
+            Driver::class,
+            Fleet::class,
+            'dynamic:customer',
+            'dynamic:driver',
+            'dynamic:facilitator'
+        );
+});
+
+test('notification service provider registers fleetops notifications and notifiables', function () {
+    $originalNotifications = NotificationRegistry::$notifications;
+    $originalNotifiables   = NotificationRegistry::$notifiables;
+
+    try {
+        NotificationRegistry::$notifications = [];
+        NotificationRegistry::$notifiables   = [];
+
+        (new NotificationServiceProvider(app()))->boot();
+
+        expect(collect(NotificationRegistry::$notifications)->pluck('definition')->all())->toBe([
+            OrderAssigned::class,
+            Fleetbase\FleetOps\Notifications\OrderCanceled::class,
+            OrderDispatchedNotification::class,
+            OrderDispatchFailed::class,
+            OrderPing::class,
+            LateDeparture::class,
+            RouteDeviation::class,
+            ProlongedStoppage::class,
+        ])
+            ->and(NotificationRegistry::$notifiables)->toBe([
+                Fleetbase\FleetOps\Models\Contact::class,
+                Driver::class,
+                Fleetbase\FleetOps\Models\Vendor::class,
+                Fleet::class,
+                'dynamic:customer',
+                'dynamic:driver',
+                'dynamic:facilitator',
+            ]);
+    } finally {
+        NotificationRegistry::$notifications = $originalNotifications;
+        NotificationRegistry::$notifiables   = $originalNotifiables;
+    }
+});
+
+test('event service provider maps order geofence and schedule listeners', function () {
+    $source = file_get_contents(dirname(__DIR__) . '/src/Providers/EventServiceProvider.php');
+
+    expect($source)->toContain(
+        OrderDispatched::class,
+        HandleOrderDispatched::class,
+        OrderCompleted::class,
+        HandleDeliveryCompletion::class,
+        GeofenceEntered::class,
+        HandleGeofenceEntered::class,
+        GeofenceExited::class,
+        HandleGeofenceExited::class,
+        GeofenceDwelled::class,
+        HandleGeofenceDwelled::class,
+        UserRemovedFromCompany::class,
+        HandleUserRemovedFromCompany::class,
+        ScheduleItemCreated::class,
+        ScheduleItemUpdated::class,
+        NotifyDriverOnShiftChange::class,
+        SendResourceLifecycleWebhook::class,
+        NotifyOrderEvent::class
+    );
+});