@fleetbase/fleetops-engine 0.6.58 → 0.6.59

package/server/tests/Unit/Http/Resources/WorkOrderResourceTest.php

@@ -0,0 +1,164 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Resources\v1\WorkOrder as WorkOrderResource;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Models\WorkOrder;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Http\Request;
+
+/**
+ * Covers the WorkOrder API resource: serialization with loaded polymorphic
+ * target/assignee relations, the Ember polymorphic type injection helpers,
+ * and the morph resource transformer with its resource-lookup fallback.
+ */
+function fleetopsWorkOrderResourceBoot(): void
+{
+    $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');
+    app()->instance('request', new Request());
+
+    $schema = $connection->getSchemaBuilder();
+    foreach ([
+        'vehicles'            => ['uuid', 'public_id', 'company_uuid', 'plate_number', 'year', 'make', 'model'],
+        'contacts'            => ['uuid', 'public_id', 'company_uuid', 'name', 'type'],
+        'custom_field_values' => ['uuid', 'subject_uuid', 'subject_type', 'custom_field_uuid', 'value', 'value_type'],
+        // Serializing a loaded Vehicle target pulls in its avatar, driver and
+        // device relations; a loaded Contact assignee pulls in its user.
+        'files'               => ['uuid', 'public_id', 'company_uuid', 'type', 'path', 'disk'],
+        'drivers'             => ['uuid', 'public_id', 'company_uuid', 'user_uuid', 'vehicle_uuid', 'status'],
+        'users'               => ['uuid', 'public_id', 'company_uuid', 'name'],
+        'devices'             => ['uuid', 'public_id', 'company_uuid', 'attachable_uuid', 'attachable_type', 'device_id', 'status'],
+        'vehicle_devices'     => ['uuid', 'vehicle_uuid', 'device_uuid'],
+        'orders'              => ['uuid', 'public_id', 'company_uuid', 'vehicle_assigned_uuid', 'driver_assigned_uuid', 'status'],
+        'places'              => ['uuid', 'public_id', 'company_uuid', 'owner_uuid', 'owner_type', 'name'],
+    ] 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();
+        });
+    }
+}
+
+function fleetopsWorkOrderResourceModel(): WorkOrder
+{
+    $workOrder = new WorkOrder();
+    $workOrder->setRawAttributes([
+        'uuid'          => 'wo-1',
+        'public_id'     => 'work_order_test',
+        'code'          => 'WO-100',
+        'subject'       => 'Replace brake pads',
+        'category'      => 'maintenance',
+        'status'        => 'open',
+        'priority'      => 'high',
+        'target_type'   => Vehicle::class,
+        'target_uuid'   => 'vehicle-1',
+        'assignee_type' => Fleetbase\FleetOps\Models\Contact::class,
+        'assignee_uuid' => 'contact-1',
+    ], true);
+    $workOrder->exists = true;
+
+    return $workOrder;
+}
+
+test('work order resource serializes core attributes and computed fields', function () {
+    fleetopsWorkOrderResourceBoot();
+
+    $payload = (new WorkOrderResource(fleetopsWorkOrderResourceModel()))->toArray(new Request());
+
+    expect($payload['code'])->toBe('WO-100')
+        ->and($payload['subject'])->toBe('Replace brake pads')
+        ->and($payload['status'])->toBe('open')
+        ->and($payload['is_overdue'])->toBeFalse()
+        ->and($payload['completion_percentage'])->toBe(0.0);
+});
+
+test('loaded polymorphic target and assignee serialize through the when loaded callbacks', function () {
+    fleetopsWorkOrderResourceBoot();
+
+    $vehicle = new Vehicle();
+    $vehicle->setRawAttributes(['uuid' => 'vehicle-1', 'public_id' => 'vehicle_test', 'plate_number' => 'SGX1234'], true);
+
+    $contact = new Fleetbase\FleetOps\Models\Contact();
+    $contact->setRawAttributes(['uuid' => 'contact-1', 'public_id' => 'contact_test', 'name' => 'Mechanic'], true);
+
+    $workOrder = fleetopsWorkOrderResourceModel();
+    $workOrder->setRelation('target', $vehicle);
+    $workOrder->setRelation('assignee', $contact);
+
+    $payload = (new WorkOrderResource($workOrder))->toArray(new Request());
+
+    // Unloaded relations are omitted entirely by whenLoaded, so reaching these
+    // keys at all is what proves the callbacks ran.
+    expect($payload['target']['subject_type'])->toBe('maintenance-subject-vehicle')
+        ->and($payload['assignee']['facilitator_type'])->toBe('facilitator-contact');
+});
+
+test('polymorphic type injection derives ember subject and facilitator slugs', function () {
+    fleetopsWorkOrderResourceBoot();
+    $resource = new WorkOrderResource(fleetopsWorkOrderResourceModel());
+
+    $setTargetType = new ReflectionMethod(WorkOrderResource::class, 'setTargetType');
+    $setTargetType->setAccessible(true);
+
+    $target = $setTargetType->invoke($resource, ['uuid' => 'vehicle-1', 'name' => 'Truck 9']);
+    expect($target['type'])->toBe('maintenance-subject-vehicle')
+        ->and($target['subject_type'])->toBe('maintenance-subject-vehicle');
+
+    // Empty resolutions pass through untouched
+    expect($setTargetType->invoke($resource, null))->toBeNull()
+        ->and($setTargetType->invoke($resource, []))->toBe([]);
+
+    $setAssigneeType = new ReflectionMethod(WorkOrderResource::class, 'setAssigneeType');
+    $setAssigneeType->setAccessible(true);
+
+    $assignee = $setAssigneeType->invoke($resource, ['uuid' => 'contact-1', 'name' => 'Mechanic']);
+    expect($assignee['type'])->toBe('facilitator-contact')
+        ->and($assignee['facilitator_type'])->toBe('facilitator-contact');
+
+    expect($setAssigneeType->invoke($resource, null))->toBeNull();
+});
+
+test('morph resource transformer resolves registered and fallback resources', function () {
+    fleetopsWorkOrderResourceBoot();
+    $resource = new WorkOrderResource(fleetopsWorkOrderResourceModel());
+
+    $transform = new ReflectionMethod(WorkOrderResource::class, 'transformMorphResource');
+    $transform->setAccessible(true);
+
+    // Null morphs resolve to null
+    expect($transform->invoke($resource, null))->toBeNull();
+
+    // Models without a registered http resource use the JsonResource fallback
+    $plain = new class extends EloquentModel {
+        protected $table = 'plain_models';
+    };
+    $plain->setRawAttributes(['uuid' => 'plain-1', 'name' => 'Plain'], true);
+
+    $resolved = $transform->invoke($resource, $plain);
+    expect($resolved)->toBeArray()
+        ->and($resolved['uuid'])->toBe('plain-1');
+});

package/server/tests/Unit/Imports/ImportDelegationTest.php

@@ -0,0 +1,151 @@
+<?php
+
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+/**
+ * Covers the createFromImport seam every spreadsheet importer exposes. The
+ * importers delegate a normalized row to their model's import factory; the
+ * feature tests stub the seam, so the delegation itself is asserted here by
+ * checking the row reaches the database.
+ */
+if (!function_exists('Fleetbase\Observers\event')) {
+    eval('namespace Fleetbase\Observers; function event($event = null, $payload = []) { return []; }');
+}
+
+if (!function_exists('Fleetbase\FleetOps\Observers\event')) {
+    eval('namespace Fleetbase\FleetOps\Observers; function event($event = null, $payload = []) { return []; }');
+}
+
+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); }');
+}
+
+function fleetopsImportSeamBoot(): SQLiteConnection
+{
+    $pdo = new PDO('sqlite::memory:');
+    foreach (['ST_PointFromText', 'ST_GeomFromText'] as $spatialFunction) {
+        $pdo->sqliteCreateFunction($spatialFunction, fn ($wkt, $srid = 0, $axisOrder = null) => $wkt);
+    }
+    if (!Illuminate\Support\Str::hasMacro('humanize')) {
+        Illuminate\Support\Str::macro('humanize', fn ($value, $uppercase = true) => str_replace('_', ' ', Illuminate\Support\Str::snake((string) $value)));
+    }
+    $connection = new SQLiteConnection($pdo);
+    $resolver   = new ConnectionResolver(['default' => $connection, 'mysql' => $connection]);
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+    if (!EloquentModel::getEventDispatcher()) {
+        EloquentModel::setEventDispatcher(new Illuminate\Events\Dispatcher());
+    }
+    app()->instance('db', new class($connection) {
+        public function __construct(public SQLiteConnection $c)
+        {
+        }
+
+        public function connection($name = null): SQLiteConnection
+        {
+            return $this->c;
+        }
+
+        public function __call($method, $arguments)
+        {
+            return $this->c->{$method}(...$arguments);
+        }
+    });
+    Illuminate\Support\Facades\DB::clearResolvedInstance('db');
+    app()->instance('responsecache', new class {
+        public function __call($method, $arguments)
+        {
+            return null;
+        }
+    });
+    config()->set('activitylog.enabled', false);
+    config()->set('activitylog.default_auth_driver', 'web');
+    app()->bind(Illuminate\Contracts\Config\Repository::class, fn () => config());
+
+    $columns = [
+        'uuid', 'public_id', 'internal_id', 'company_uuid', 'name', 'email', 'phone', 'title', 'status', 'type',
+        'meta', '_key', '_import_id', 'slug', 'description', 'sku', 'serial_number', 'model', 'make', 'year',
+        'plate_number', 'vin', 'report', 'amount', 'currency', 'volume', 'metric_unit', 'odometer',
+        'street1', 'street2', 'city', 'province', 'postal_code', 'country', 'location', 'phone_country_code',
+        'vendor_uuid', 'driver_uuid', 'vehicle_uuid', 'place_uuid', 'owner_uuid', 'owner_type', 'user_uuid',
+        'service_area_uuid', 'parent_fleet_uuid', 'zone_uuid', 'order_uuid', 'subject_uuid', 'subject_type',
+        'assignee_uuid', 'priority', 'category', 'due_at', 'scheduled_at',
+        'avatar_url', 'trim', 'call_sign', 'fuel_card_number', 'online', 'code', 'manufacturer',
+        'purchase_price', 'purchased_at', 'driver_name', 'assigned_to_uuid', 'reported_by_uuid',
+        'cost', 'quantity', 'unit', 'warranty_uuid', 'asset_uuid', 'equipable_uuid', 'equipable_type',
+        'maintainable_uuid', 'maintainable_type', 'target_uuid', 'target_type', 'interval', 'notes',
+        'barcode', 'quantity_on_hand', 'unit_cost', 'msrp', 'subject', 'instructions', 'opened_at',
+        'estimated_cost', 'approved_budget', 'actual_cost', 'cost_center', 'budget_code',
+        'summary', 'started_at', 'completed_at', 'engine_hours', 'labor_cost', 'parts_cost', 'tax',
+        'total_cost', 'interval_method', 'interval_type', 'interval_value', 'interval_unit',
+        'interval_distance', 'interval_engine_hours', 'last_service_odometer', 'last_service_engine_hours',
+        'last_service_date', 'next_due_date', 'next_due_odometer', 'next_due_engine_hours', 'default_priority',
+    ];
+
+    $schema = $connection->getSchemaBuilder();
+    foreach ([
+        'contacts', 'drivers', 'fleets', 'issues', 'places', 'vehicles', 'vendors', 'fuel_reports',
+        'equipments', 'maintenances', 'maintenance_schedules', 'parts', 'work_orders', 'users', 'companies',
+    ] as $table) {
+        $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();
+        });
+    }
+
+    app()->instance('geocoder', new class {
+        public function geocode($address)
+        {
+            return $this;
+        }
+
+        public function reverse($latitude, $longitude)
+        {
+            return $this;
+        }
+
+        public function get()
+        {
+            return collect();
+        }
+    });
+    Geocoder\Laravel\Facades\Geocoder::clearResolvedInstances();
+
+    session(['company' => 'company-import-1']);
+    $connection->table('companies')->insert(['uuid' => 'company-import-1', 'name' => 'Import Co']);
+
+    return $connection;
+}
+
+test('importers delegate rows to their model import factory', function (string $importClass, string $table, array $row) {
+    $connection = fleetopsImportSeamBoot();
+
+    $import     = new $importClass();
+    $reflection = new ReflectionMethod($importClass, 'createFromImport');
+    $reflection->setAccessible(true);
+    $reflection->invoke($import, $row);
+
+    // The delegated row is persisted for the session company
+    expect($connection->table($table)->count())->toBe(1)
+        ->and($connection->table($table)->value('company_uuid'))->toBe('company-import-1');
+})->with([
+    'contacts'                => [Fleetbase\FleetOps\Imports\ContactImport::class, 'contacts', ['name' => 'Imported Contact', 'email' => 'contact@example.test']],
+    'fleets'                  => [Fleetbase\FleetOps\Imports\FleetImport::class, 'fleets', ['name' => 'Imported Fleet']],
+    'issues'                  => [Fleetbase\FleetOps\Imports\IssueImport::class, 'issues', ['report' => 'Imported Issue', 'latitude' => 1.30, 'longitude' => 103.80]],
+    'vendors'                 => [Fleetbase\FleetOps\Imports\VendorImport::class, 'vendors', ['name' => 'Imported Vendor']],
+    'vehicles'                => [Fleetbase\FleetOps\Imports\VehicleImport::class, 'vehicles', ['make' => 'Toyota', 'model' => 'HiAce', 'plate_number' => 'SG-1234']],
+    'equipment'               => [Fleetbase\FleetOps\Imports\EquipmentImport::class, 'equipments', ['name' => 'Imported Equipment']],
+    'parts'                   => [Fleetbase\FleetOps\Imports\PartImport::class, 'parts', ['name' => 'Imported Part']],
+    'work orders'             => [Fleetbase\FleetOps\Imports\WorkOrderImport::class, 'work_orders', ['name' => 'Imported Work Order']],
+    'fuel reports'            => [Fleetbase\FleetOps\Imports\FuelReportImport::class, 'fuel_reports', ['report' => 'Imported Fuel Report', 'amount' => 50, 'volume' => 30]],
+    'issues with coordinates' => [Fleetbase\FleetOps\Imports\IssueImport::class, 'issues', ['report' => 'Located Issue', 'latitude' => 1.30, 'longitude' => 103.80]],
+    'maintenances'            => [Fleetbase\FleetOps\Imports\MaintenanceImport::class, 'maintenances', ['name' => 'Imported Maintenance']],
+    'maintenance schedules'   => [Fleetbase\FleetOps\Imports\MaintenanceScheduleImport::class, 'maintenance_schedules', ['name' => 'Imported Schedule']],
+    'places'                  => [Fleetbase\FleetOps\Imports\PlaceImport::class, 'places', ['name' => 'Imported Place', 'latitude' => 1.30, 'longitude' => 103.80]],
+]);

package/server/tests/Unit/Integrations/Lalamove/LalamoveDeliveryStopTest.php

@@ -0,0 +1,79 @@
+<?php
+
+use Fleetbase\FleetOps\Integrations\Lalamove\LalamoveDeliveryStop;
+use Fleetbase\FleetOps\Models\Place;
+use Fleetbase\LaravelMysqlSpatial\Eloquent\SpatialExpression;
+use Fleetbase\LaravelMysqlSpatial\Types\Point;
+
+function fleetopsLalamoveDeliveryStopDisableRedisCache(): void
+{
+    app()->instance('redis', new class {
+        public function connection(): self
+        {
+            return $this;
+        }
+
+        public function __call(string $method, array $arguments): mixed
+        {
+            return null;
+        }
+    });
+}
+
+function fleetopsLalamoveDeliveryStopPlace(Point|SpatialExpression $location, string $address = '12 Depot Road'): Place
+{
+    $place = new Place();
+    $place->setRawAttributes([
+        'uuid'     => 'place-uuid',
+        'location' => $location,
+        'street1'  => $address,
+        'city'     => 'Singapore',
+        'country'  => 'SG',
+    ], true);
+
+    return $place;
+}
+
+test('lalamove delivery stop can be created from points and raw coordinates', function () {
+    $pointStop = LalamoveDeliveryStop::createFromPoint(new Point(1.29027, 103.851959), 'Marina Depot');
+    $rawStop   = new LalamoveDeliveryStop(1.3521, 103.8198, 'Central Depot');
+
+    expect($pointStop->latitude)->toBe(1.29027)
+        ->and($pointStop->longitude)->toBe(103.851959)
+        ->and($pointStop->address)->toBe('Marina Depot')
+        ->and($pointStop->stopId)->toBeString()
+        ->and($pointStop->missing)->toBeNull()
+        ->and($pointStop->toArray())->toBe([
+            'coordinates' => [
+                'lat' => '1.29027',
+                'lng' => '103.851959',
+            ],
+            'address' => 'Marina Depot',
+        ])
+        ->and(json_decode($pointStop->toJson(), true))->toBe($pointStop->toArray())
+        ->and($pointStop->toPoint())->toBeInstanceOf(Point::class)
+        ->and($rawStop->toArray())->toMatchArray([
+            'coordinates' => [
+                'lat' => '1.3521',
+                'lng' => '103.8198',
+            ],
+            'address' => 'Central Depot',
+        ]);
+});
+
+test('lalamove delivery stop resolves place point and spatial expression locations', function () {
+    fleetopsLalamoveDeliveryStopDisableRedisCache();
+
+    $pointPlace   = fleetopsLalamoveDeliveryStopPlace(new Point(1.3001, 103.8002), 'Point Place');
+    $spatialPlace = fleetopsLalamoveDeliveryStopPlace(new SpatialExpression(new Point(1.4001, 103.9002)), 'Spatial Place');
+
+    $pointStop   = LalamoveDeliveryStop::createFromPlace($pointPlace);
+    $spatialStop = new LalamoveDeliveryStop($spatialPlace);
+
+    expect($pointStop->latitude)->toBe(1.3001)
+        ->and($pointStop->longitude)->toBe(103.8002)
+        ->and($pointStop->address)->toBe('POINT PLACE - SINGAPORE')
+        ->and($spatialStop->latitude)->toBe(1.4001)
+        ->and($spatialStop->longitude)->toBe(103.9002)
+        ->and($spatialStop->address)->toBe('SPATIAL PLACE - SINGAPORE');
+});

package/server/tests/Unit/Integrations/Lalamove/LalamoveLifecycleTest.php

@@ -0,0 +1,211 @@
+<?php
+
+if (!function_exists('Fleetbase\Traits\config')) {
+    eval('namespace Fleetbase\Traits; function config($key = null, $default = null) { return $key === "api.cache.enabled" ? false : $default; }');
+}
+
+if (!function_exists('Fleetbase\Traits\app')) {
+    eval('namespace Fleetbase\Traits; function app($abstract = null) { return new \stdClass(); }');
+}
+
+if (!function_exists('Fleetbase\Models\config')) {
+    eval('namespace Fleetbase\Models; function config($key = null, $default = null) { return $key === "fleetbase.connection.db" ? "mysql" : $default; }');
+}
+
+if (!function_exists('Fleetbase\FleetOps\Integrations\Lalamove\session')) {
+    eval('namespace Fleetbase\FleetOps\Integrations\Lalamove; function session($key = null, $default = null) { return $key === "company" ? "company-session" : $default; }');
+}
+
+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); }');
+}
+
+use Fleetbase\FleetOps\Exceptions\IntegratedVendorException;
+use Fleetbase\FleetOps\Integrations\Lalamove\Lalamove;
+use Fleetbase\FleetOps\Integrations\Lalamove\LalamoveMarket;
+use Fleetbase\FleetOps\Integrations\Lalamove\LalamoveServiceType;
+use Fleetbase\FleetOps\Models\Contact;
+use Fleetbase\FleetOps\Models\IntegratedVendor;
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\LaravelMysqlSpatial\Types\Point;
+use GuzzleHttp\Client;
+use GuzzleHttp\Handler\MockHandler;
+use GuzzleHttp\HandlerStack;
+use GuzzleHttp\Middleware;
+use GuzzleHttp\Psr7\Response;
+
+function fleetopsLalamoveLifecycleWithResponses(array $responses, array &$history = []): Lalamove
+{
+    $mock    = new MockHandler($responses);
+    $history = [];
+    $stack   = HandlerStack::create($mock);
+    $stack->push(Middleware::history($history));
+    $client = new Client([
+        'base_uri' => 'https://rest.sandbox.lalamove.com/v3/',
+        'handler'  => $stack,
+    ]);
+
+    $lalamove = new Lalamove('api-key', 'api-secret', true, 'SG');
+    $property = new ReflectionProperty($lalamove, 'client');
+    $property->setAccessible(true);
+    $property->setValue($lalamove, $client);
+
+    return $lalamove;
+}
+
+function fleetopsLalamoveLifecycleProperty(object $target, string $property): mixed
+{
+    $reflection = new ReflectionProperty($target, $property);
+    $reflection->setAccessible(true);
+
+    return $reflection->getValue($target);
+}
+
+test('lalamove direct instances retain provided credentials and static dispatch forwards arguments in order', function () {
+    $instance = Lalamove::instance('api-key', 'api-secret', true, 'SG');
+
+    expect($instance)->toBeInstanceOf(Lalamove::class)
+        ->and(fleetopsLalamoveLifecycleProperty($instance, 'apiKey'))->toBe('api-key')
+        ->and(fleetopsLalamoveLifecycleProperty($instance, 'apiSecret'))->toBe('api-secret')
+        ->and(fleetopsLalamoveLifecycleProperty($instance, 'isSandbox'))->toBeTrue();
+
+    // Unknown proxied methods resolve an instance and return null.
+    expect(Lalamove::fromHostMissingMethod())->toBeNull();
+});
+
+test('lalamove accepts market service type and integrated vendor objects', function () {
+    $market           = LalamoveMarket::find('SG');
+    $serviceType      = LalamoveServiceType::find('MOTORCYCLE');
+    $integratedVendor = new IntegratedVendor();
+    $integratedVendor->setRawAttributes([
+        'uuid'      => 'integrated-vendor-uuid',
+        'public_id' => 'vendor_public',
+    ], true);
+    $integratedVendor->setAppends([]);
+
+    $lalamove = new Lalamove('api-key', 'api-secret', true, $market);
+
+    expect(Lalamove::getMarket($market))->toBe($market)
+        ->and(Lalamove::getServiceType($serviceType))->toBe($serviceType)
+        ->and($lalamove->setMarket($market))->toBe($lalamove)
+        ->and($lalamove->setIntegratedVendor($integratedVendor))->toBe($lalamove)
+        ->and(fleetopsLalamoveLifecycleProperty($lalamove, 'integratedVendor'))->toBe($integratedVendor)
+        ->and(fleetopsLalamoveLifecycleProperty($lalamove, 'market'))->toBe($market);
+});
+
+test('lalamove quotation requests include route options item cod and schedule data', function () {
+    $history  = [];
+    $lalamove = fleetopsLalamoveLifecycleWithResponses([
+        new Response(200, [], json_encode(['data' => ['quotationId' => 'quotation-1']])),
+    ], $history);
+
+    $response = $lalamove->getQuotations(
+        'MOTORCYCLE',
+        [
+            new Point(1.3001, 103.8002),
+            new Point(1.4001, 103.9002),
+        ],
+        '2026-08-15T12:30:00+00:00',
+        ['PURCHASE_SERVICE'],
+        false,
+        ['quantity' => '1', 'weight' => 'LESS_THAN_3KG'],
+        ['amount'   => '1000'],
+    );
+
+    $body = json_decode((string) $history[0]['request']->getBody(), true);
+
+    expect($response->data->quotationId)->toBe('quotation-1')
+        ->and($history[0]['request']->getMethod())->toBe('POST')
+        ->and((string) $history[0]['request']->getUri())->toContain('/v3/quotations')
+        ->and($history[0]['request']->getHeaderLine('Market'))->toBe('SG')
+        ->and($body['data']['serviceType'])->toBe('MOTORCYCLE')
+        ->and($body['data']['language'])->toBe('en_SG')
+        ->and($body['data']['stops'][0]['coordinates'])->toBe(['lat' => '1.3001', 'lng' => '103.8002'])
+        ->and($body['data']['isRouteOptimized'])->toBeFalse()
+        ->and($body['data']['specialRequests'])->toBe(['PURCHASE_SERVICE'])
+        ->and($body['data']['item'])->toBe(['quantity' => '1', 'weight' => 'LESS_THAN_3KG'])
+        ->and($body['data']['cashOnDelivery'])->toBe(['amount' => '1000'])
+        ->and($body['data']['scheduleAt'])->toBe('2026-08-15T12:30:00.000000Z');
+});
+
+test('lalamove normalizes contact senders and returns response data from order creation', function () {
+    $history  = [];
+    $lalamove = fleetopsLalamoveLifecycleWithResponses([
+        new Response(200, [], json_encode(['data' => ['orderId' => 'order-1', 'status' => 'ASSIGNING_DRIVER']])),
+    ], $history);
+
+    $sender = new Contact();
+    $sender->setRawAttributes([
+        'name'  => 'Sender Contact',
+        'phone' => '+18004444444',
+    ], true);
+    $sender->setAppends([]);
+
+    $order = $lalamove->createOrder('quotation-1', $sender, [
+        ['stopId' => 'dropoff', 'name' => 'Recipient', 'phone' => '+18005555555'],
+    ]);
+
+    $body = json_decode((string) $history[0]['request']->getBody(), true);
+
+    expect($order)->toMatchObject([
+        'orderId' => 'order-1',
+        'status'  => 'ASSIGNING_DRIVER',
+    ])
+        ->and($body['data']['sender'])->toBe([
+            'name'  => 'Sender Contact',
+            'phone' => '+18004444444',
+        ])
+        ->and($body['data']['isRecipientSMSEnabled'])->toBeFalse()
+        ->and($body['data']['isPODEnabled'])->toBeFalse()
+        ->and($body['data']['metadata'])->toBe([]);
+});
+
+test('lalamove cancels fleetbase orders using integrated vendor order metadata', function () {
+    $history  = [];
+    $lalamove = fleetopsLalamoveLifecycleWithResponses([
+        new Response(200, [], json_encode(['data' => ['orderId' => 'order-1', 'status' => 'CANCELED']])),
+    ], $history);
+
+    $order = new Order();
+    $order->setRawAttributes([
+        'uuid'      => 'order-uuid',
+        'public_id' => 'order_public',
+        'meta'      => [
+            'integrated_vendor_order' => ['orderId' => 'order-1'],
+        ],
+    ], true);
+    $order->setAppends([]);
+
+    $response = $lalamove->cancelFromFleetbaseOrder($order);
+
+    expect($response->data->status)->toBe('CANCELED')
+        ->and($history[0]['request']->getMethod())->toBe('DELETE')
+        ->and((string) $history[0]['request']->getUri())->toContain('/v3/orders/order-1');
+});
+
+test('lalamove webhook lifecycle ignores empty urls returns data and throws vendor errors', function () {
+    $history  = [];
+    $lalamove = fleetopsLalamoveLifecycleWithResponses([
+        new Response(200, [], json_encode(['data' => ['url' => 'https://hooks.example/lalamove']])),
+        new Response(200, [], json_encode([
+            'errors' => [
+                ['id' => 'WEBHOOK_ERROR', 'message' => 'Invalid webhook', 'detail' => 'URL rejected'],
+            ],
+        ])),
+    ], $history);
+
+    expect($lalamove->setWebhook())->toBeNull()
+        ->and($history)->toBe([]);
+
+    $webhook = $lalamove->setWebhook('https://hooks.example/lalamove');
+
+    expect($webhook)->toMatchObject(['url' => 'https://hooks.example/lalamove'])
+        ->and($history[0]['request']->getMethod())->toBe('PATCH')
+        ->and((string) $history[0]['request']->getUri())->toContain('/v3/webhook')
+        ->and(json_decode((string) $history[0]['request']->getBody(), true))->toBe([
+            'data' => ['url' => 'https://hooks.example/lalamove'],
+        ]);
+
+    expect(fn () => $lalamove->setWebhook('https://hooks.example/rejected'))
+        ->toThrow(IntegratedVendorException::class, 'Lalamove: WEBHOOK_ERROR Invalid webhook (URL rejected)');
+});