@fleetbase/fleetops-engine 0.6.57 → 0.6.59

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

@@ -0,0 +1,361 @@
+<?php
+
+use Fleetbase\FleetOps\Exports\VehicleExport;
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\VehicleController;
+use Fleetbase\FleetOps\Models\Device;
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\Http\Requests\ExportRequest;
+use Fleetbase\Http\Requests\ImportRequest;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\Eloquent\ModelNotFoundException;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+/**
+ * Covers the internal VehicleController's database-backed endpoints and the
+ * real bodies of its lookup helpers: driver assignment syncing, assigned and
+ * unassigned order management, vehicle/driver/device lookups, status and
+ * avatar options, and the excel export/import endpoints.
+ */
+if (!class_exists('Fleetbase\Http\Requests\ExportRequest', false)) {
+    eval('namespace Fleetbase\Http\Requests; class ExportRequest extends \Illuminate\Http\Request {}');
+}
+
+if (!class_exists('Fleetbase\Http\Requests\ImportRequest', false)) {
+    eval('namespace Fleetbase\Http\Requests; class ImportRequest extends \Illuminate\Http\Request {}');
+}
+
+if (!Request::hasMacro('resolveFilesFromIds')) {
+    Request::macro('resolveFilesFromIds', fn () => FleetOpsInternalVehicleEndpointsState::$files);
+}
+
+class FleetOpsInternalVehicleEndpointsState
+{
+    public static array $files = [];
+}
+
+class FleetOpsInternalVehicleEndpointsExcelFake
+{
+    public array $downloads  = [];
+    public array $imports    = [];
+    public bool $importFails = false;
+
+    public function download($export, string $fileName): string
+    {
+        $this->downloads[] = [$export, $fileName];
+
+        return 'downloaded:' . $fileName;
+    }
+
+    public function import($import, $path, $disk = null): bool
+    {
+        if ($this->importFails) {
+            throw new RuntimeException('corrupt file');
+        }
+
+        $this->imports[] = [$import, $path, $disk];
+        $import->imported++;
+
+        return true;
+    }
+}
+
+class FleetOpsInternalVehicleEndpointsVehicleFake extends Vehicle
+{
+    protected $guarded         = [];
+    public $exists             = true;
+    public array $assignments  = [];
+
+    public function assignDriver($driver, bool $save = true): self
+    {
+        $this->assignments[] = ['assign', $driver->uuid];
+
+        return $this;
+    }
+
+    public function unassignDriver(bool $save = true): self
+    {
+        $this->assignments[] = ['unassign'];
+
+        return $this;
+    }
+}
+
+class FleetOpsInternalVehicleEndpointsProbe extends VehicleController
+{
+    public function callProtected(string $method, array $arguments = []): mixed
+    {
+        $reflection = new ReflectionMethod(VehicleController::class, $method);
+        $reflection->setAccessible(true);
+
+        return $reflection->invoke($this, ...$arguments);
+    }
+
+    protected function activeOrderUuid(Vehicle $vehicle): ?string
+    {
+        return null;
+    }
+}
+
+function fleetopsInternalVehicleEndpointsBoot(): 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);
+        }
+    });
+    app()->instance('request', Request::create('/int/v1/vehicles'));
+    Illuminate\Support\Facades\DB::clearResolvedInstance('db');
+
+    $schema = $connection->getSchemaBuilder();
+    $tables = [
+        'vehicles'  => ['uuid', 'public_id', 'company_uuid', 'driver_uuid', 'status', 'plate_number', 'year', 'make', 'model'],
+        'drivers'   => ['uuid', 'public_id', 'company_uuid', 'vehicle_uuid', 'user_uuid', 'current_job_uuid'],
+        'users'     => ['uuid', 'public_id', 'company_uuid'],
+        'devices'   => ['uuid', 'public_id', 'company_uuid', 'attachable_uuid', 'attachable_type'],
+        'orders'    => ['uuid', 'public_id', 'company_uuid', 'vehicle_assigned_uuid', 'driver_assigned_uuid', 'payload_uuid', 'tracking_number_uuid', 'order_config_uuid', 'status', 'scheduled_at', 'dispatched_at'],
+        'files'     => ['uuid', 'type', 'original_filename', 'company_uuid'],
+        'positions' => ['uuid', 'company_uuid', 'subject_uuid', 'subject_type', 'order_uuid'],
+    ];
+    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 fleetopsInternalVehicleEndpointsSeedVehicle(SQLiteConnection $connection, string $uuid = 'vehicle-1'): void
+{
+    $connection->table('vehicles')->insert([
+        'uuid'         => $uuid,
+        'public_id'    => 'vehicle_' . $uuid,
+        'company_uuid' => 'company-1',
+    ]);
+}
+
+function fleetopsInternalVehicleEndpointsExcel(): FleetOpsInternalVehicleEndpointsExcelFake
+{
+    $fake = new FleetOpsInternalVehicleEndpointsExcelFake();
+    app()->instance('excel', $fake);
+    Maatwebsite\Excel\Facades\Excel::clearResolvedInstance('excel');
+
+    return $fake;
+}
+
+/*
+|--------------------------------------------------------------------------
+| Driver assignment syncing
+|--------------------------------------------------------------------------
+*/
+
+test('sync driver assignment unassigns the driver when no identifier is given', function () {
+    fleetopsInternalVehicleEndpointsBoot();
+    $vehicle = new FleetOpsInternalVehicleEndpointsVehicleFake();
+
+    (new FleetOpsInternalVehicleEndpointsProbe())->callProtected('syncDriverAssignment', [$vehicle, null]);
+
+    expect($vehicle->assignments)->toBe([['unassign']]);
+});
+
+test('sync driver assignment assigns a matching company driver', function () {
+    $connection = fleetopsInternalVehicleEndpointsBoot();
+    $connection->table('drivers')->insert(['uuid' => 'driver-1', 'public_id' => 'driver_test', 'company_uuid' => 'company-1']);
+    $vehicle = new FleetOpsInternalVehicleEndpointsVehicleFake();
+
+    (new FleetOpsInternalVehicleEndpointsProbe())->callProtected('syncDriverAssignment', [$vehicle, 'driver_test']);
+
+    expect($vehicle->assignments)->toBe([['assign', 'driver-1']])
+        ->and($vehicle->getRelation('driver')->uuid)->toBe('driver-1');
+});
+
+test('sync driver assignment ignores identifiers with no matching driver', function () {
+    fleetopsInternalVehicleEndpointsBoot();
+    $vehicle = new FleetOpsInternalVehicleEndpointsVehicleFake();
+
+    (new FleetOpsInternalVehicleEndpointsProbe())->callProtected('syncDriverAssignment', [$vehicle, 'driver_unknown']);
+
+    expect($vehicle->assignments)->toBe([]);
+});
+
+/*
+|--------------------------------------------------------------------------
+| Order assignment endpoints
+|--------------------------------------------------------------------------
+*/
+
+test('assigned orders endpoint lists orders assigned to the vehicle', function () {
+    $connection = fleetopsInternalVehicleEndpointsBoot();
+    fleetopsInternalVehicleEndpointsSeedVehicle($connection);
+    $connection->table('orders')->insert([
+        'uuid'                  => 'order-1',
+        'public_id'             => 'order_test',
+        'company_uuid'          => 'company-1',
+        'vehicle_assigned_uuid' => 'vehicle-1',
+        'status'                => 'created',
+    ]);
+
+    $response = (new FleetOpsInternalVehicleEndpointsProbe())->assignedOrders('vehicle-1');
+
+    expect($response)->toBeInstanceOf(JsonResponse::class);
+    $data = $response->getData(true);
+    expect($data['status'])->toBe('ok')
+        ->and($data['count'])->toBe(1)
+        ->and($data['orders'][0]['id'])->toBe('order_test');
+});
+
+test('unassign orders endpoint errors when no assigned orders match', function () {
+    $connection = fleetopsInternalVehicleEndpointsBoot();
+    fleetopsInternalVehicleEndpointsSeedVehicle($connection);
+
+    $request  = Request::create('/int/v1/vehicles/vehicle-1/unassign-orders', 'POST', ['orders' => ['order_missing']]);
+    $response = (new FleetOpsInternalVehicleEndpointsProbe())->unassignOrders($request, 'vehicle-1');
+
+    expect($response->getData(true))->toBe(['error' => 'No assigned orders were selected for this vehicle.']);
+});
+
+test('unassign orders endpoint removes the vehicle from selected orders', function () {
+    $connection = fleetopsInternalVehicleEndpointsBoot();
+    fleetopsInternalVehicleEndpointsSeedVehicle($connection);
+    $connection->table('orders')->insert([
+        'uuid'                  => 'order-1',
+        'public_id'             => 'order_test',
+        'company_uuid'          => 'company-1',
+        'vehicle_assigned_uuid' => 'vehicle-1',
+        'status'                => 'created',
+    ]);
+
+    $request  = Request::create('/int/v1/vehicles/vehicle-1/unassign-orders', 'POST', ['orders' => ['order-1']]);
+    $response = (new FleetOpsInternalVehicleEndpointsProbe())->unassignOrders($request, 'vehicle-1');
+
+    $data = $response->getData(true);
+    expect($data['status'])->toBe('ok')
+        ->and($data['count'])->toBe(1)
+        ->and($connection->table('orders')->where('uuid', 'order-1')->value('vehicle_assigned_uuid'))->toBeNull();
+});
+
+/*
+|--------------------------------------------------------------------------
+| Lookup helpers
+|--------------------------------------------------------------------------
+*/
+
+test('vehicle and driver lookup helpers resolve records scoped to the company', function () {
+    $connection = fleetopsInternalVehicleEndpointsBoot();
+    fleetopsInternalVehicleEndpointsSeedVehicle($connection);
+    $connection->table('users')->insert(['uuid' => 'user-1', 'company_uuid' => 'company-1']);
+    $connection->table('drivers')->insert(['uuid' => 'driver-1', 'public_id' => 'driver_test', 'company_uuid' => 'company-1', 'user_uuid' => 'user-1']);
+    $connection->table('devices')->insert(['uuid' => 'device-1', 'public_id' => 'device_test', 'company_uuid' => 'company-1']);
+
+    $probe = new FleetOpsInternalVehicleEndpointsProbe();
+
+    expect($probe->callProtected('findVehicle', ['vehicle-1']))->toBeInstanceOf(Vehicle::class)
+        ->and($probe->callProtected('resolveVehicle', ['vehicle-1']))->toBeInstanceOf(Vehicle::class)
+        ->and($probe->callProtected('resolveVehicle', ['missing']))->toBeNull()
+        ->and($probe->callProtected('findDriver', ['driver_test']))->toBeInstanceOf(Driver::class)
+        ->and($probe->callProtected('resolveDevice', ['device_test']))->toBeInstanceOf(Device::class)
+        ->and($probe->callProtected('resolveDevice', ['missing']))->toBeNull()
+        ->and($probe->callProtected('findDevice', ['device-1']))->toBeInstanceOf(Device::class);
+
+    expect(fn () => $probe->callProtected('findVehicle', ['missing']))->toThrow(ModelNotFoundException::class)
+        ->and(fn () => $probe->callProtected('findDriver', ['missing']))->toThrow(ModelNotFoundException::class)
+        ->and(fn () => $probe->callProtected('findDevice', ['missing']))->toThrow(ModelNotFoundException::class);
+});
+
+/*
+|--------------------------------------------------------------------------
+| Options endpoints
+|--------------------------------------------------------------------------
+*/
+
+test('statuses endpoint returns distinct non-empty company vehicle statuses', function () {
+    $connection = fleetopsInternalVehicleEndpointsBoot();
+    $connection->table('vehicles')->insert([
+        ['uuid' => 'v1', 'company_uuid' => 'company-1', 'status' => 'active'],
+        ['uuid' => 'v2', 'company_uuid' => 'company-1', 'status' => 'active'],
+        ['uuid' => 'v3', 'company_uuid' => 'company-1', 'status' => 'maintenance'],
+        ['uuid' => 'v4', 'company_uuid' => 'company-1', 'status' => null],
+        ['uuid' => 'v5', 'company_uuid' => 'other-company', 'status' => 'inactive'],
+    ]);
+
+    $response = (new VehicleController())->statuses();
+
+    expect($response)->toBeInstanceOf(JsonResponse::class)
+        ->and(collect($response->getData(true))->sort()->values()->all())->toBe(['active', 'maintenance']);
+});
+
+test('avatars endpoint merges custom company avatars with defaults', function () {
+    $connection = fleetopsInternalVehicleEndpointsBoot();
+    $connection->table('files')->insert([
+        'uuid'              => 'file-1',
+        'type'              => 'vehicle-avatar',
+        'original_filename' => 'fleet-truck.svg',
+        'company_uuid'      => 'company-1',
+    ]);
+
+    $response = (new VehicleController())->avatars();
+
+    expect($response)->toBeInstanceOf(JsonResponse::class);
+    $options = $response->getData(true);
+    expect($options)->toHaveKey('Custom: fleet-truck');
+});
+
+/*
+|--------------------------------------------------------------------------
+| Export and import endpoints
+|--------------------------------------------------------------------------
+*/
+
+test('export endpoint streams a vehicle export download', function () {
+    $excel = fleetopsInternalVehicleEndpointsExcel();
+
+    $request  = ExportRequest::create('/int/v1/vehicles/export', 'POST', ['format' => 'csv', 'selections' => ['vehicle-1']]);
+    $response = VehicleController::export($request);
+
+    expect($response)->toStartWith('downloaded:vehicles-')
+        ->and($response)->toEndWith('.csv')
+        ->and($excel->downloads[0][0])->toBeInstanceOf(VehicleExport::class);
+});
+
+test('import endpoint imports resolved files and reports failures', function () {
+    $excel                                        = fleetopsInternalVehicleEndpointsExcel();
+    FleetOpsInternalVehicleEndpointsState::$files = [
+        (object) ['path' => 'uploads/vehicles-a.xlsx'],
+    ];
+
+    $request  = ImportRequest::create('/int/v1/vehicles/import', 'POST', ['disk' => 'local']);
+    $response = (new VehicleController())->import($request);
+
+    expect($response->getData(true))->toBe(['status' => 'ok', 'message' => 'Import completed', 'imported' => 1])
+        ->and($excel->imports)->toHaveCount(1);
+
+    $excel->importFails = true;
+    $failure            = (new VehicleController())->import($request);
+
+    expect($failure->getData(true))->toBe(['error' => 'Invalid file, unable to proccess.']);
+});

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

@@ -0,0 +1,203 @@
+<?php
+
+use Fleetbase\FleetOps\Exports\VendorExport;
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\VendorController;
+use Fleetbase\FleetOps\Models\Contact;
+use Fleetbase\FleetOps\Models\Vendor;
+use Fleetbase\FleetOps\Models\VendorPersonnel;
+use Fleetbase\Http\Requests\ExportRequest;
+use Fleetbase\Http\Requests\ImportRequest;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Http\Request;
+
+/**
+ * Covers the internal VendorController export/statuses/import endpoints and
+ * the protected lookup and personnel helpers against SQLite with an excel
+ * fake.
+ */
+if (!class_exists('Fleetbase\Http\Requests\ExportRequest', false)) {
+    eval('namespace Fleetbase\Http\Requests; class ExportRequest extends \Illuminate\Http\Request {}');
+}
+
+if (!class_exists('Fleetbase\Http\Requests\ImportRequest', false)) {
+    eval('namespace Fleetbase\Http\Requests; class ImportRequest extends \Illuminate\Http\Request {}');
+}
+
+if (!Request::hasMacro('resolveFilesFromIds')) {
+    Request::macro('resolveFilesFromIds', fn () => FleetOpsInternalVendorEndpointsState::$files);
+}
+
+class FleetOpsInternalVendorEndpointsState
+{
+    public static array $files = [];
+}
+
+class FleetOpsInternalVendorEndpointsExcelFake
+{
+    public array $downloads  = [];
+    public array $imports    = [];
+    public bool $importFails = false;
+
+    public function download($export, string $fileName): string
+    {
+        $this->downloads[] = [$export, $fileName];
+
+        return 'downloaded:' . $fileName;
+    }
+
+    public function import($import, $path, $disk = null): bool
+    {
+        if ($this->importFails) {
+            throw new RuntimeException('corrupt file');
+        }
+
+        $this->imports[] = [$import, $path, $disk];
+        $import->imported++;
+
+        return true;
+    }
+}
+
+class FleetOpsInternalVendorEndpointsProbe extends VendorController
+{
+    public function callProtected(string $method, array $arguments = []): mixed
+    {
+        $reflection = new ReflectionMethod(VendorController::class, $method);
+        $reflection->setAccessible(true);
+
+        return $reflection->invoke($this, ...$arguments);
+    }
+}
+
+function fleetopsInternalVendorEndpointsBoot(): 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');
+    app()->instance('request', Request::create('/int/v1/vendors'));
+
+    $excelFake = new FleetOpsInternalVendorEndpointsExcelFake();
+    app()->instance('excel', $excelFake);
+    Maatwebsite\Excel\Facades\Excel::clearResolvedInstance('excel');
+    $GLOBALS['fleetopsVendorExcelFake'] = $excelFake;
+
+    $schema = $connection->getSchemaBuilder();
+    $tables = [
+        'vendors'             => ['uuid', 'public_id', 'internal_id', 'company_uuid', 'name', 'email', 'phone', 'status', 'type', 'place_uuid', 'logo_uuid', 'business_id', 'website_url', 'meta', 'callbacks', 'slug'],
+        'contacts'            => ['uuid', 'public_id', 'internal_id', 'company_uuid', 'user_uuid', 'name', 'title', 'email', 'phone', 'type', 'place_uuid', 'photo_uuid', 'meta', 'slug'],
+        'vendor_personnels'   => ['uuid', 'vendor_uuid', 'contact_uuid', 'company_uuid', 'role', 'status'],
+        'drivers'             => ['uuid', 'public_id', 'company_uuid', 'user_uuid', 'status'],
+        'users'               => ['uuid', 'public_id', 'company_uuid', 'name'],
+        'places'              => ['uuid', 'public_id', 'company_uuid', 'owner_uuid', 'name', 'street1', 'location'],
+        'custom_field_values' => ['uuid', 'subject_uuid', 'subject_type', 'custom_field_uuid', 'value', 'value_type'],
+    ];
+    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;
+}
+
+test('export streams a vendor export and statuses list distinct values', function () {
+    $connection = fleetopsInternalVendorEndpointsBoot();
+    $connection->table('vendors')->insert([
+        ['uuid' => 'vendor-1', 'company_uuid' => 'company-1', 'name' => 'A', 'status' => 'active'],
+        ['uuid' => 'vendor-2', 'company_uuid' => 'company-1', 'name' => 'B', 'status' => 'pending'],
+        ['uuid' => 'vendor-3', 'company_uuid' => 'company-1', 'name' => 'C', 'status' => 'active'],
+    ]);
+
+    $request  = ExportRequest::create('/int/v1/vendors/export', 'POST', ['format' => 'csv', 'selections' => ['vendor-1']]);
+    $response = VendorController::export($request);
+    expect($response)->toStartWith('downloaded:vendors-')
+        ->and($response)->toEndWith('.csv')
+        ->and($GLOBALS['fleetopsVendorExcelFake']->downloads[0][0])->toBeInstanceOf(VendorExport::class);
+
+    $statuses = (new VendorController())->statuses();
+    expect($statuses->getData(true))->toBe(['active', 'pending']);
+});
+
+test('import processes resolved files and reports invalid files', function () {
+    fleetopsInternalVendorEndpointsBoot();
+    FleetOpsInternalVendorEndpointsState::$files = [
+        (object) ['path' => 'uploads/vendors-a.xlsx'],
+    ];
+
+    $request  = ImportRequest::create('/int/v1/vendors/import', 'POST', ['disk' => 'local']);
+    $response = (new VendorController())->import($request);
+    expect($response->getData(true))->toBe(['status' => 'ok', 'message' => 'Import completed', 'imported' => 1]);
+
+    $GLOBALS['fleetopsVendorExcelFake']->importFails = true;
+    $failure                                         = (new VendorController())->import($request);
+    expect($failure->getData(true))->toBe(['error' => 'Invalid file, unable to proccess.']);
+});
+
+test('vendor and contact lookup helpers resolve records', function () {
+    $connection = fleetopsInternalVendorEndpointsBoot();
+    $connection->table('vendors')->insert(['uuid' => 'vendor-1', 'public_id' => 'vendor_test', 'company_uuid' => 'company-1', 'name' => 'A']);
+    $connection->table('users')->insert(['uuid' => 'user-1', 'company_uuid' => 'company-1']);
+    $connection->table('drivers')->insert(['uuid' => 'driver-1', 'company_uuid' => 'company-1', 'user_uuid' => 'user-1']);
+    $connection->table('contacts')->insert(['uuid' => 'contact-1', 'public_id' => 'contact_test', 'company_uuid' => 'company-1', 'name' => 'C', 'type' => 'contact']);
+
+    $probe = new FleetOpsInternalVendorEndpointsProbe();
+
+    expect($probe->callProtected('findVendorByUuid', ['vendor-1'])?->uuid)->toBe('vendor-1')
+        ->and($probe->callProtected('findVendorWithTrashedByUuid', ['vendor-1'])?->uuid)->toBe('vendor-1')
+        ->and($probe->callProtected('findDriverByUuid', ['driver-1'])?->uuid)->toBe('driver-1')
+        ->and($probe->callProtected('findVendorByIdOrFail', ['vendor_test']))->toBeInstanceOf(Vendor::class)
+        ->and($probe->callProtected('findContactByIdOrFail', ['contact_test']))->toBeInstanceOf(Contact::class)
+        ->and($probe->callProtected('findPersonnelContact', ['contact-1']))->toBeInstanceOf(Contact::class);
+
+    $payload = $probe->callProtected('contactResourcePayload', [Contact::where('uuid', 'contact-1')->first()]);
+    expect($payload)->toBeArray()->and($payload['name'])->toBe('C');
+});
+
+test('vendor personnel helpers persist update and delete assignments', function () {
+    $connection = fleetopsInternalVendorEndpointsBoot();
+    $connection->table('contacts')->insert(['uuid' => 'contact-1', 'public_id' => 'contact_test', 'company_uuid' => 'company-1', 'name' => 'C', 'type' => 'contact']);
+
+    $probe = new FleetOpsInternalVendorEndpointsProbe();
+
+    $personnel = $probe->callProtected('updateOrCreateVendorPersonnel', [
+        ['vendor_uuid' => 'vendor-1', 'contact_uuid' => 'contact-1'],
+        ['company_uuid' => 'company-1', 'role' => 'manager'],
+    ]);
+    expect($personnel)->toBeInstanceOf(VendorPersonnel::class)
+        ->and($connection->table('vendor_personnels')->count())->toBe(1);
+
+    $listed = $probe->callProtected('queryVendorPersonnel', ['vendor-1']);
+    expect($listed)->toHaveCount(1);
+
+    $created = $probe->callProtected('createPersonnelContact', [['company_uuid' => 'company-1', 'name' => 'New Contact', 'type' => 'contact']]);
+    expect($created)->toBeInstanceOf(Contact::class);
+
+    $probe->callProtected('deleteVendorPersonnel', ['vendor-1', 'contact-1']);
+    expect($connection->table('vendor_personnels')->whereNull('deleted_at')->count())->toBe(0);
+});