@fleetbase/fleetops-engine 0.6.58 → 0.6.59

package/server/tests/Feature/Http/Internal/OrchestrationControllerHelpersTest.php

@@ -0,0 +1,214 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\OrchestrationController;
+use Fleetbase\FleetOps\Models\Contact;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Models\Vendor;
+use Fleetbase\FleetOps\Orchestration\Engines\DriverAssignmentEngine;
+use Fleetbase\FleetOps\Orchestration\Engines\RouteSequencingEngine;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+/**
+ * Covers the real bodies of the internal OrchestrationController's protected
+ * helper methods against an in-memory SQLite fixture: order/vehicle/driver
+ * query scopes, engine construction, transaction management, waypoint
+ * sequencing, order-config custom field lookups, and customer/facilitator
+ * contact and vendor resolution.
+ */
+class FleetOpsOrchestrationHelpersProbe extends OrchestrationController
+{
+    public function callProtected(string $method, mixed ...$arguments): mixed
+    {
+        $reflection = new ReflectionMethod(OrchestrationController::class, $method);
+        $reflection->setAccessible(true);
+
+        return $reflection->invoke($this, ...$arguments);
+    }
+}
+
+function fleetopsOrchestrationHelpersBoot(): 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 = [
+        'orders'         => ['uuid', 'public_id', 'company_uuid', 'payload_uuid', 'status'],
+        'vehicles'       => ['uuid', 'public_id', 'company_uuid', 'driver_uuid'],
+        'drivers'        => ['uuid', 'public_id', 'company_uuid', 'user_uuid', 'vehicle_uuid'],
+        'users'          => ['uuid', 'public_id', 'company_uuid'],
+        'waypoints'      => ['uuid', 'public_id', 'company_uuid', 'payload_uuid', 'place_uuid', 'order'],
+        'contacts'       => ['uuid', 'public_id', 'company_uuid', 'name', 'email', 'phone', 'type'],
+        'vendors'        => ['uuid', 'public_id', 'company_uuid', 'name', 'email', 'phone'],
+        'order_configs'  => ['uuid', 'public_id', 'company_uuid', 'name', 'key'],
+        'custom_fields'  => ['uuid', 'public_id', 'company_uuid', 'subject_uuid', 'subject_type', 'name', 'label', 'type', 'required', 'order'],
+        'settings'       => ['key', 'value'],
+        'schedule_items' => ['uuid', 'public_id', 'company_uuid', 'assignee_uuid', 'assignee_type', 'status'],
+        'manifests'      => ['uuid', 'public_id', 'company_uuid', 'vehicle_uuid', 'driver_uuid', 'status', 'meta', '_key'],
+        'manifest_stops' => ['uuid', 'public_id', 'company_uuid', 'manifest_uuid', 'order_uuid', 'waypoint_uuid', 'sequence', 'type', 'meta', '_key'],
+    ];
+    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;
+}
+
+function fleetopsOrchestrationHelpersProbe(): FleetOpsOrchestrationHelpersProbe
+{
+    return app(FleetOpsOrchestrationHelpersProbe::class);
+}
+
+test('query scope helpers filter orders vehicles and drivers', function () {
+    $connection = fleetopsOrchestrationHelpersBoot();
+    $connection->table('orders')->insert([
+        ['uuid' => 'order-1', 'public_id' => 'order_a', 'company_uuid' => 'company-1', 'payload_uuid' => null, 'status' => 'created'],
+        ['uuid' => 'order-2', 'public_id' => 'order_b', 'company_uuid' => 'company-1', 'payload_uuid' => null, 'status' => 'completed'],
+    ]);
+    $connection->table('users')->insert(['uuid' => 'user-1', 'company_uuid' => 'company-1']);
+    $connection->table('drivers')->insert(['uuid' => 'driver-1', 'public_id' => 'driver_a', 'company_uuid' => 'company-1', 'user_uuid' => 'user-1', 'vehicle_uuid' => 'vehicle-1']);
+    $connection->table('vehicles')->insert(['uuid' => 'vehicle-1', 'public_id' => 'vehicle_a', 'company_uuid' => 'company-1']);
+
+    $probe = fleetopsOrchestrationHelpersProbe();
+
+    expect($probe->callProtected('companyUuid'))->toBe('company-1')
+        ->and($probe->callProtected('orchestratorOrdersQuery', 'company-1')->count())->toBe(1)
+        ->and($probe->callProtected('orchestrationRunOrdersQuery', 'company-1')->get())->toHaveCount(1)
+        ->and($probe->callProtected('orchestrationRunVehiclesQuery', 'company-1')->get())->toHaveCount(1);
+
+    $drivers = $probe->callProtected('driversByPublicId', ['driver_a']);
+    expect($drivers->has('driver_a'))->toBeTrue();
+
+    expect($probe->callProtected('vehicleByPublicIdWithDriver', 'vehicle_a'))->toBeInstanceOf(Vehicle::class)
+        ->and($probe->callProtected('vehicleByPublicIdWithDriver', 'missing'))->toBeNull()
+        ->and($probe->callProtected('vehicleByUuidWithDriver', 'vehicle-1'))->toBeInstanceOf(Vehicle::class)
+        ->and($probe->callProtected('vehicleByUuidWithDriver', 'missing'))->toBeNull();
+});
+
+test('engine and transaction helpers execute their real bodies', function () {
+    fleetopsOrchestrationHelpersBoot();
+    $probe = fleetopsOrchestrationHelpersProbe();
+
+    expect($probe->callProtected('driverAssignmentEngine'))->toBeInstanceOf(DriverAssignmentEngine::class)
+        ->and($probe->callProtected('routeSequencingEngine'))->toBeInstanceOf(RouteSequencingEngine::class)
+        ->and($probe->callProtected('orchestratorEngineSetting'))->toBe('greedy');
+
+    $probe->callProtected('beginOrchestrationTransaction');
+    $probe->callProtected('commitOrchestrationTransaction');
+    $probe->callProtected('beginOrchestrationTransaction');
+    $probe->callProtected('rollBackOrchestrationTransaction');
+
+    expect(true)->toBeTrue();
+});
+
+test('waypoint sequence helper updates the waypoint order column', function () {
+    $connection = fleetopsOrchestrationHelpersBoot();
+    $connection->table('waypoints')->insert(['uuid' => 'waypoint-1', 'public_id' => 'waypoint_a', 'payload_uuid' => 'payload-1', 'order' => '0']);
+
+    fleetopsOrchestrationHelpersProbe()->callProtected('updateWaypointSequence', 'payload-1', 'waypoint_a', 3);
+
+    expect($connection->table('waypoints')->value('order'))->toBe('3');
+});
+
+test('order config field helpers load configs and fall back to direct custom field queries', function () {
+    $connection = fleetopsOrchestrationHelpersBoot();
+    $connection->table('order_configs')->insert(['uuid' => 'config-1', 'public_id' => 'order_config_a', 'company_uuid' => 'company-1', 'name' => 'Transport', 'key' => 'transport']);
+    $connection->table('custom_fields')->insert(['uuid' => 'field-1', 'subject_uuid' => 'config-1', 'subject_type' => 'order-config', 'name' => 'priority', 'label' => 'Priority', 'type' => 'text', 'order' => '1']);
+
+    $probe   = fleetopsOrchestrationHelpersProbe();
+    $configs = $probe->callProtected('getOrderConfigFieldConfigs', 'company-1');
+    expect($configs)->toHaveCount(1);
+
+    $fields = $probe->callProtected('getCustomFieldsForOrderConfig', 'config-1');
+    expect($fields)->toHaveCount(1)
+        ->and($fields->first()->name)->toBe('priority');
+});
+
+test('resolve or create contact matches by email phone or creates customers', function () {
+    $connection = fleetopsOrchestrationHelpersBoot();
+    $connection->table('contacts')->insert(['uuid' => 'contact-1', 'company_uuid' => 'company-1', 'email' => 'known@example.com', 'phone' => '+15550001', 'name' => 'Known', 'type' => 'customer']);
+
+    $probe = fleetopsOrchestrationHelpersProbe();
+
+    $byEmail = $probe->callProtected('resolveOrCreateContact', ['customer_email' => 'known@example.com'], 'company-1', 'customer');
+    expect($byEmail)->toBeInstanceOf(Contact::class)
+        ->and($byEmail->uuid)->toBe('contact-1');
+
+    $byPhone = $probe->callProtected('resolveOrCreateContact', ['customer_phone' => '+15550001'], 'company-1', 'customer');
+    expect($byPhone?->uuid)->toBe('contact-1');
+
+    $created = $probe->callProtected('resolveOrCreateContact', ['customer_name' => 'New Customer', 'customer_email' => 'new@example.com'], 'company-1', 'customer');
+    expect($created)->toBeInstanceOf(Contact::class)
+        ->and($connection->table('contacts')->count())->toBe(2);
+
+    expect($probe->callProtected('resolveOrCreateContact', [], 'company-1', 'customer'))->toBeNull();
+});
+
+test('resolve or create vendor matches by email phone name or creates vendors', function () {
+    $connection = fleetopsOrchestrationHelpersBoot();
+    $connection->table('vendors')->insert(['uuid' => 'vendor-1', 'company_uuid' => 'company-1', 'email' => 'acme@example.com', 'phone' => '+15550009', 'name' => 'Acme Logistics']);
+
+    $probe = fleetopsOrchestrationHelpersProbe();
+
+    expect($probe->callProtected('resolveOrCreateVendor', ['facilitator_email' => 'acme@example.com'], 'company-1', 'facilitator')?->uuid)->toBe('vendor-1')
+        ->and($probe->callProtected('resolveOrCreateVendor', ['facilitator_phone' => '+15550009'], 'company-1', 'facilitator')?->uuid)->toBe('vendor-1')
+        ->and($probe->callProtected('resolveOrCreateVendor', ['facilitator_name' => 'ACME LOGISTICS'], 'company-1', 'facilitator')?->uuid)->toBe('vendor-1');
+
+    $created = $probe->callProtected('resolveOrCreateVendor', ['facilitator_name' => 'New Vendor'], 'company-1', 'facilitator');
+    expect($created)->toBeInstanceOf(Vendor::class)
+        ->and($connection->table('vendors')->count())->toBe(2);
+
+    expect($probe->callProtected('resolveOrCreateVendor', [], 'company-1', 'facilitator'))->toBeNull();
+});
+
+test('record lookup and manifest creation helpers persist rows', function () {
+    $connection = fleetopsOrchestrationHelpersBoot();
+    $connection->table('orders')->insert(['uuid' => 'order-1', 'public_id' => 'order_manif1', 'company_uuid' => 'company-1', 'status' => 'created']);
+    $connection->table('users')->insert(['uuid' => 'user-1', 'company_uuid' => 'company-1']);
+    $connection->table('drivers')->insert(['uuid' => 'driver-1', 'public_id' => 'driver_manif1', 'company_uuid' => 'company-1', 'user_uuid' => 'user-1']);
+    $connection->table('vehicles')->insert(['uuid' => 'vehicle-1', 'public_id' => 'vehicle_manif1', 'company_uuid' => 'company-1']);
+
+    $probe = fleetopsOrchestrationHelpersProbe();
+
+    expect($probe->callProtected('findVehicleByPublicId', 'vehicle_manif1')?->uuid)->toBe('vehicle-1')
+        ->and($probe->callProtected('findDriverByPublicId', 'driver_manif1')?->uuid)->toBe('driver-1')
+        ->and($probe->callProtected('findOrderByPublicId', 'order_manif1')?->uuid)->toBe('order-1')
+        ->and($probe->callProtected('findVehicleByPublicId', 'vehicle_missing'))->toBeNull();
+
+    $manifest = $probe->callProtected('createManifest', ['company_uuid' => 'company-1', 'vehicle_uuid' => 'vehicle-1', 'status' => 'pending']);
+    expect($connection->table('manifests')->count())->toBe(1);
+
+    $probe->callProtected('createManifestStop', ['company_uuid' => 'company-1', 'manifest_uuid' => $manifest->uuid, 'order_uuid' => 'order-1', 'sequence' => 1]);
+    expect($connection->table('manifest_stops')->count())->toBe(1);
+
+    expect($probe->callProtected('orchestrationTransactionLevel'))->toBeInt();
+});

package/server/tests/Feature/Http/Internal/OrchestrationControllerImportOrdersTest.php

@@ -0,0 +1,340 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\OrchestrationController;
+use Fleetbase\FleetOps\Orchestration\OrchestrationEngineRegistry;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Http\Request;
+use Illuminate\Support\Str;
+
+/**
+ * Covers the internal OrchestrationController importOrders endpoint against
+ * SQLite: the empty-rows rejection, single pickup/dropoff row imports with
+ * customer/facilitator/vehicle/driver resolution and entity attachment,
+ * multi-waypoint groups collapsing into one order with waypoints, and the
+ * per-group failure capture with rollback.
+ */
+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; } }; }');
+}
+
+if (!function_exists('Fleetbase\FleetOps\Models\event')) {
+    eval('namespace Fleetbase\FleetOps\Models; function event($event = null) { return $event; }');
+}
+
+if (!function_exists('Fleetbase\FleetOps\Models\dispatch')) {
+    eval('namespace Fleetbase\FleetOps\Models; function dispatch($job = null) { return new \Fleetbase\TestSupport\PendingDispatch(); }');
+}
+
+function fleetopsOrchImportBoot(): SQLiteConnection
+{
+    if (!Str::hasMacro('humanize')) {
+        Str::macro('humanize', fn ($value, $uppercase = true) => str_replace('_', ' ', Str::snake((string) $value)));
+    }
+
+    $pdo = new PDO('sqlite::memory:');
+    $pdo->sqliteCreateFunction('ST_PointFromText', fn ($wkt, $srid = 0, $axisOrder = null) => $wkt);
+    $pdo->sqliteCreateFunction('ST_GeomFromText', fn ($wkt, $srid = 0, $axisOrder = null) => $wkt);
+    $pdo->sqliteCreateFunction('ST_Equals', fn ($a, $b) => $a === $b ? 1 : 0);
+    $connection = new SQLiteConnection($pdo);
+    $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('geocoder', new class {
+        public $results;
+
+        public function geocode($address)
+        {
+            return $this;
+        }
+
+        public function reverse($latitude, $longitude)
+        {
+            return $this;
+        }
+
+        public function get()
+        {
+            return collect();
+        }
+    });
+    Geocoder\Laravel\Facades\Geocoder::clearResolvedInstances();
+
+    $barcodeFake = new class {
+        public function __call($method, $arguments)
+        {
+            return 'barcode';
+        }
+    };
+    app()->instance('DNS2D', $barcodeFake);
+    app()->instance('DNS1D', $barcodeFake);
+
+    $schema = $connection->getSchemaBuilder();
+    app()->instance('db.schema', $schema);
+    $tables = [
+        'orders'            => ['uuid', 'public_id', 'internal_id', 'company_uuid', 'payload_uuid', 'order_config_uuid', 'tracking_number_uuid', 'driver_assigned_uuid', 'vehicle_assigned_uuid', 'customer_uuid', 'customer_type', 'facilitator_uuid', 'facilitator_type', 'status', 'type', 'adhoc', 'dispatched', 'started', 'scheduled_at', 'notes', 'meta', 'time_window_start', 'time_window_end', 'required_skills', 'orchestrator_priority', 'distance', 'time', 'pod_required', 'pod_method', 'created_by_uuid', 'updated_by_uuid'],
+        'payloads'          => ['uuid', 'public_id', 'company_uuid', 'pickup_uuid', 'dropoff_uuid', 'return_uuid', 'current_waypoint_uuid', 'meta', 'type', 'cod_amount', 'cod_currency', 'cod_payment_method', 'capacity_weight_kg', 'capacity_volume_m3', 'capacity_parcels', '_key'],
+        'places'            => ['uuid', 'public_id', 'company_uuid', 'name', 'street1', 'street2', 'city', 'province', 'postal_code', 'country', 'phone', 'location', 'meta', '_key', 'owner_uuid', 'type', '_import_id'],
+        'waypoints'         => ['uuid', 'public_id', 'company_uuid', 'payload_uuid', 'place_uuid', 'tracking_number_uuid', 'order', 'type', '_import_id', '_key'],
+        'entities'          => ['uuid', 'public_id', 'company_uuid', 'payload_uuid', 'destination_uuid', 'tracking_number_uuid', 'name', 'type', 'weight', 'weight_unit', 'meta', '_import_id', '_key', 'internal_id', 'sku', 'height', 'width', 'length', 'dimensions_unit', 'declared_value', 'currency', 'description'],
+        'contacts'          => ['uuid', 'public_id', 'internal_id', 'company_uuid', 'user_uuid', 'name', 'email', 'phone', 'type', 'meta', 'slug', '_key'],
+        'vendors'           => ['uuid', 'public_id', 'internal_id', 'company_uuid', 'name', 'email', 'phone', 'status', 'type', 'meta', 'slug', '_key'],
+        'vehicles'          => ['uuid', 'public_id', 'company_uuid', 'name', 'plate_number', 'make', 'model', 'year'],
+        'drivers'           => ['uuid', 'public_id', 'company_uuid', 'user_uuid', 'drivers_license_number', 'status'],
+        'users'             => ['uuid', 'public_id', 'company_uuid', 'name', 'email', 'phone', 'status', 'type'],
+        'order_configs'     => ['uuid', 'public_id', 'company_uuid', 'name', 'key', 'namespace', 'description', 'flow', 'entities', 'meta', 'version', 'core_service', 'status', 'type', '_key'],
+        'tracking_numbers'  => ['uuid', 'public_id', 'company_uuid', 'tracking_number', 'region', 'location', 'status_uuid', 'owner_uuid', 'owner_type', 'qr_code', 'barcode', '_key'],
+        'tracking_statuses' => ['uuid', 'public_id', 'company_uuid', 'tracking_number_uuid', 'proof_uuid', 'status', 'details', 'location', 'code', 'complete', '_key'],
+        'companies'         => ['uuid', 'public_id', 'name', 'country'],
+    ];
+    foreach ($tables as $table => $columns) {
+        $schema->create($table, function ($blueprint) use ($columns) {
+            $blueprint->increments('id');
+            foreach ($columns as $column) {
+                if ($column === 'core_service') {
+                    $blueprint->integer($column)->nullable();
+                    continue;
+                }
+                $blueprint->string($column)->nullable();
+            }
+            $blueprint->timestamps();
+            $blueprint->timestamp('deleted_at')->nullable();
+        });
+    }
+
+    session(['company' => 'company-1']);
+    $connection->table('companies')->insert(['uuid' => 'company-1', 'name' => 'Acme', 'country' => 'SG']);
+    $connection->table('order_configs')->insert([
+        'uuid'         => 'config-1',
+        'public_id'    => 'order_config_transport',
+        'company_uuid' => 'company-1',
+        'name'         => 'Transport',
+        'key'          => 'transport',
+        'namespace'    => 'system:order-config:transport',
+        'core_service' => 1,
+        'status'       => 'active',
+        'version'      => '0.0.1',
+        'flow'         => json_encode([]),
+    ]);
+
+    return $connection;
+}
+
+function fleetopsOrchImportController(): OrchestrationController
+{
+    return new OrchestrationController(new OrchestrationEngineRegistry());
+}
+
+test('import orders rejects empty row sets', function () {
+    fleetopsOrchImportBoot();
+
+    $response = fleetopsOrchImportController()->importOrders(Request::create('/x', 'POST', []));
+
+    expect($response->getStatusCode())->toBe(422)
+        ->and($response->getData(true)['error'])->toContain('No rows');
+});
+
+test('import orders creates a pickup dropoff order with resolutions', function () {
+    $connection = fleetopsOrchImportBoot();
+    $connection->table('vehicles')->insert(['uuid' => 'vehicle-1', 'company_uuid' => 'company-1', 'plate_number' => 'ATL-1']);
+    $connection->table('users')->insert(['uuid' => 'user-1', 'company_uuid' => 'company-1', 'name' => 'Casey Driver', 'email' => 'casey@example.test']);
+    $connection->table('drivers')->insert(['uuid' => 'driver-1', 'public_id' => 'driver_import', 'company_uuid' => 'company-1', 'user_uuid' => 'user-1']);
+
+    $response = fleetopsOrchImportController()->importOrders(Request::create('/x', 'POST', ['rows' => [[
+        'order_type'          => 'pickup_dropoff',
+        'type'                => 'transport',
+        'customer_name'       => 'Import Customer',
+        'customer_email'      => 'import.customer@example.test',
+        'facilitator_name'    => 'Import Vendor',
+        'facilitator_email'   => 'import.vendor@example.test',
+        'vehicle_plate'       => 'ATL-1',
+        'driver_email'        => 'casey@example.test',
+        'pickup_name'         => 'Warehouse',
+        'pickup_street1'      => '1 Import Way',
+        'pickup_city'         => 'Singapore',
+        'pickup_country'      => 'SG',
+        'pickup_lat'          => '1.30',
+        'pickup_lng'          => '103.80',
+        'dropoff_name'        => 'Customer Site',
+        'dropoff_street1'     => '9 Delivery Road',
+        'dropoff_city'        => 'Singapore',
+        'dropoff_country'     => 'SG',
+        'dropoff_lat'         => '1.35',
+        'dropoff_lng'         => '103.85',
+        'entity_name'         => 'Parcel A',
+        'priority'            => '10',
+        'required_skills'     => 'refrigerated, fragile',
+        'service_time_min'    => '15',
+    ]]]));
+
+    $result = $response->getData(true);
+
+    expect($result['failed'])->toBe([])
+        ->and(count($result['created']))->toBe(1)
+        ->and($connection->table('orders')->count())->toBe(1)
+        ->and($connection->table('orders')->value('vehicle_assigned_uuid'))->toBe('vehicle-1')
+        ->and($connection->table('orders')->value('driver_assigned_uuid'))->toBe('driver-1')
+        ->and($connection->table('contacts')->where('email', 'import.customer@example.test')->count())->toBe(1)
+        ->and($connection->table('vendors')->where('email', 'import.vendor@example.test')->count())->toBe(1)
+        ->and($connection->table('places')->count())->toBe(2);
+});
+
+test('import orders collapses multi waypoint groups into one order', function () {
+    $connection = fleetopsOrchImportBoot();
+
+    $rows = [
+        [
+            'order_type'      => 'multi_waypoint',
+            'order_ref'       => 'GROUP-1',
+            'dropoff_name'    => 'Stop One',
+            'dropoff_street1' => '1 First Stop',
+            'dropoff_city'    => 'Singapore',
+            'dropoff_country' => 'SG',
+            'dropoff_lat'     => '1.30',
+            'dropoff_lng'     => '103.80',
+        ],
+        [
+            'order_type'      => 'multi_waypoint',
+            'order_ref'       => 'GROUP-1',
+            'dropoff_name'    => 'Stop Two',
+            'dropoff_street1' => '2 Second Stop',
+            'dropoff_city'    => 'Singapore',
+            'dropoff_country' => 'SG',
+            'dropoff_lat'     => '1.31',
+            'dropoff_lng'     => '103.81',
+            'entity_name'     => 'Grouped Parcel',
+        ],
+    ];
+
+    $response = fleetopsOrchImportController()->importOrders(Request::create('/x', 'POST', ['rows' => $rows]));
+    $result   = $response->getData(true);
+
+    expect($result['failed'])->toBe([])
+        ->and(count($result['created']))->toBe(1)
+        ->and($connection->table('orders')->count())->toBe(1)
+        ->and($connection->table('waypoints')->count())->toBe(2);
+});
+
+test('import orders captures per group failures with rollback', function () {
+    $connection = fleetopsOrchImportBoot();
+
+    $response = fleetopsOrchImportController()->importOrders(Request::create('/x', 'POST', ['rows' => [[
+        'order_type'   => 'pickup_dropoff',
+        'scheduled_at' => 'not-a-real-date',
+        '_rowIndex'    => 3,
+    ]]]));
+
+    $result = $response->getData(true);
+
+    expect($result['created'])->toBe([])
+        ->and(count($result['failed']))->toBe(1)
+        ->and($result['failed'][0]['row'])->toBe(3);
+});
+
+test('import orders resolves swapped customer and facilitator entity types', function () {
+    $connection = fleetopsOrchImportBoot();
+
+    $response = fleetopsOrchImportController()->importOrders(Request::create('/x', 'POST', ['rows' => [[
+        'order_type'        => 'pickup_dropoff',
+        'type'              => 'transport',
+        // A vendor customer and a contact facilitator invert the defaults
+        'customer_type'     => 'vendor',
+        'customer_name'     => 'Wholesale Buyer',
+        'customer_email'    => 'buyer@example.test',
+        'facilitator_type'  => 'contact',
+        'facilitator_name'  => 'Broker Contact',
+        'facilitator_email' => 'broker@example.test',
+        'pickup_name'       => 'Warehouse',
+        'pickup_lat'        => '1.30',
+        'pickup_lng'        => '103.80',
+        'dropoff_name'      => 'Customer Site',
+        'dropoff_lat'       => '1.35',
+        'dropoff_lng'       => '103.85',
+    ]]]));
+
+    expect($response->getData(true)['failed'])->toBe([])
+        ->and($connection->table('orders')->value('customer_type'))->toContain('Vendor')
+        ->and($connection->table('orders')->value('facilitator_type'))->toContain('Contact')
+        ->and($connection->table('vendors')->where('email', 'buyer@example.test')->count())->toBe(1)
+        ->and($connection->table('contacts')->where('email', 'broker@example.test')->count())->toBe(1);
+});
+
+test('multi waypoint entities resolve destinations by index and by name', function () {
+    $connection = fleetopsOrchImportBoot();
+
+    $rows = [
+        [
+            'order_type'      => 'multi_waypoint',
+            'order_ref'       => 'GROUP-DEST',
+            'type'            => 'transport',
+            'dropoff_name'    => 'Stop One',
+            'dropoff_street1' => '1 First Road',
+            'dropoff_lat'     => '1.30',
+            'dropoff_lng'     => '103.80',
+        ],
+        [
+            'order_type'      => 'multi_waypoint',
+            'order_ref'       => 'GROUP-DEST',
+            'dropoff_name'    => 'Stop Two',
+            'dropoff_street1' => '2 Second Road',
+            'dropoff_lat'     => '1.35',
+            'dropoff_lng'     => '103.85',
+        ],
+        [
+            // No address of its own: the numeric destination points at stop one
+            'order_type'         => 'multi_waypoint',
+            'order_ref'          => 'GROUP-DEST',
+            'entity_name'        => 'Indexed Parcel',
+            'entity_destination' => '0',
+        ],
+        [
+            // A non-numeric destination is carried through as a name
+            'order_type'         => 'multi_waypoint',
+            'order_ref'          => 'GROUP-DEST',
+            'entity_name'        => 'Named Parcel',
+            'entity_destination' => 'dropoff',
+        ],
+    ];
+
+    $response = fleetopsOrchImportController()->importOrders(Request::create('/x', 'POST', ['rows' => $rows]));
+
+    expect($response->getData(true)['failed'])->toBe([])
+        ->and($connection->table('orders')->count())->toBe(1)
+        ->and($connection->table('entities')->whereIn('name', ['Indexed Parcel', 'Named Parcel'])->count())->toBe(2);
+});
+
+test('zero and blank coordinates resolve to no point', function () {
+    fleetopsOrchImportBoot();
+
+    $controller = fleetopsOrchImportController();
+    $reflection = new ReflectionMethod(OrchestrationController::class, 'buildLocationPoint');
+    $reflection->setAccessible(true);
+
+    // Blank coordinates and the null island both mean "no location given"
+    expect($reflection->invoke($controller, '', ''))->toBeNull()
+        // '0.0' is non-empty but still the null island
+        ->and($reflection->invoke($controller, '0.0', '0.0'))->toBeNull()
+        ->and($reflection->invoke($controller, '1.30', '103.80'))->not->toBeNull();
+});