@fleetbase/fleetops-engine 0.6.58 → 0.6.59

package/server/tests/MaintenanceScheduleControllerContractsTest.php

@@ -0,0 +1,101 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\MaintenanceScheduleController;
+use Illuminate\Support\Carbon;
+
+class FleetOpsMaintenanceScheduleControllerProbe extends MaintenanceScheduleController
+{
+    public function callHelper(string $method, mixed ...$arguments): mixed
+    {
+        $reflection = new ReflectionMethod(MaintenanceScheduleController::class, $method);
+        $reflection->setAccessible(true);
+
+        return $reflection->invoke($this, ...$arguments);
+    }
+}
+
+function fleetopsMaintenanceSchedule(array $attributes, ?object $subject = null, ?object $assignee = null): object
+{
+    return (object) [
+        ...$attributes,
+        'uuid'            => $attributes['uuid'] ?? 'schedule-uuid',
+        'public_id'       => $attributes['public_id'] ?? 'schedule_public',
+        'subject'         => $subject,
+        'defaultAssignee' => $assignee,
+    ];
+}
+
+test('maintenance schedule controller expands recurring calendar events inside window', function () {
+    $controller = new FleetOpsMaintenanceScheduleControllerProbe();
+    $schedule   = fleetopsMaintenanceSchedule([
+        'uuid'             => 'schedule-uuid',
+        'public_id'        => 'schedule_public',
+        'name'             => 'Quarterly inspection',
+        'status'           => 'active',
+        'type'             => 'inspection',
+        'default_priority' => 'high',
+        'interval_value'   => 2,
+        'interval_unit'    => 'days',
+        'next_due_date'    => Carbon::parse('2026-01-01'),
+    ], (object) ['display_name' => 'Truck 9'], (object) ['name' => 'Vendor Ops']);
+
+    $events = $controller->callHelper(
+        'calendarEventsForSchedules',
+        [$schedule],
+        Carbon::parse('2026-01-02')->startOfDay(),
+        Carbon::parse('2026-01-07')->endOfDay()
+    );
+
+    expect(array_column($events, 'occurrence_date'))->toBe(['2026-01-03', '2026-01-05', '2026-01-07'])
+        ->and($events[0])->toMatchArray([
+            'id'            => 'schedule_public',
+            'uuid'          => 'schedule-uuid',
+            'title'         => 'Quarterly inspection — Truck 9',
+            'allDay'        => true,
+            'status'        => 'active',
+            'priority'      => 'high',
+            'type'          => 'inspection',
+            'subject_name'  => 'Truck 9',
+            'assignee_name' => 'Vendor Ops',
+            'color'         => '#f97316',
+            'start'         => '2026-01-03',
+            'end'           => '2026-01-03',
+        ]);
+});
+
+test('maintenance schedule controller emits one-off events only inside window', function () {
+    $controller = new FleetOpsMaintenanceScheduleControllerProbe();
+    $inside     = fleetopsMaintenanceSchedule([
+        'name'             => 'Annual service',
+        'status'           => 'active',
+        'type'             => 'service',
+        'default_priority' => 'low',
+        'next_due_date'    => Carbon::parse('2026-02-10'),
+    ], (object) ['public_id' => 'asset_public']);
+    $outside = fleetopsMaintenanceSchedule([
+        'name'             => 'Outside service',
+        'status'           => 'active',
+        'type'             => 'service',
+        'default_priority' => 'critical',
+        'next_due_date'    => Carbon::parse('2026-03-10'),
+    ]);
+
+    $events = $controller->callHelper(
+        'calendarEventsForSchedules',
+        [$inside, $outside],
+        Carbon::parse('2026-02-01')->startOfDay(),
+        Carbon::parse('2026-02-28')->endOfDay()
+    );
+
+    expect($events)->toHaveCount(1)
+        ->and($events[0])->toMatchArray([
+            'title'        => 'Annual service — asset_public',
+            'subject_name' => 'asset_public',
+            'color'        => '#22c55e',
+            'start'        => '2026-02-10',
+            'end'          => '2026-02-10',
+        ])
+        ->and($controller->callHelper('eventColorForPriority', 'critical'))->toBe('#ef4444')
+        ->and($controller->callHelper('eventColorForPriority', 'normal'))->toBe('#3b82f6')
+        ->and($controller->callHelper('eventColorForPriority', 'unknown'))->toBe('#6b7280');
+});

package/server/tests/MaintenanceWarrantyContractsTest.php

@@ -0,0 +1,237 @@
+<?php
+
+use Fleetbase\FleetOps\Models\Asset;
+use Fleetbase\FleetOps\Models\MaintenanceSchedule;
+use Fleetbase\FleetOps\Models\ServiceArea;
+use Fleetbase\FleetOps\Models\TrackingNumber;
+use Fleetbase\FleetOps\Models\Warranty;
+use Fleetbase\FleetOps\Models\Zone;
+use Fleetbase\LaravelMysqlSpatial\Types\MultiPolygon;
+use Fleetbase\LaravelMysqlSpatial\Types\Point;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+use Illuminate\Database\Eloquent\Relations\HasOne;
+use Illuminate\Database\Eloquent\Relations\MorphTo;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Support\Carbon;
+
+function fleetopsMaintenanceUseInMemoryRelationConnection(): void
+{
+    $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
+    $resolver   = new ConnectionResolver([
+        'default' => $connection,
+        'mysql'   => $connection,
+    ]);
+
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+}
+
+class FleetOpsUpdatingMaintenanceScheduleFake extends MaintenanceSchedule
+{
+    public array $updates = [];
+
+    public function getDateFormat()
+    {
+        return 'Y-m-d H:i:s';
+    }
+
+    public function update(array $attributes = [], array $options = []): bool
+    {
+        $this->updates[] = $attributes;
+        $this->forceFill($attributes);
+
+        return true;
+    }
+}
+
+class FleetOpsUpdatingWarrantyFake extends Warranty
+{
+    public array $updates = [];
+
+    public function getDateFormat()
+    {
+        return 'Y-m-d H:i:s';
+    }
+
+    public function update(array $attributes = [], array $options = []): bool
+    {
+        $this->updates[] = $attributes;
+        $this->forceFill($attributes);
+
+        return false;
+    }
+}
+
+test('maintenance schedule due checks reset lifecycle and import mapping are stable', function () {
+    Carbon::setTestNow(Carbon::parse('2026-01-15 12:00:00'));
+
+    $schedule = new FleetOpsUpdatingMaintenanceScheduleFake([
+        'status'                     => 'active',
+        'interval_value'             => 30,
+        'interval_unit'              => 'days',
+        'interval_distance'          => 5000,
+        'interval_engine_hours'      => 250,
+        'last_service_odometer'      => 10000,
+        'last_service_engine_hours'  => 400,
+        'last_service_date'          => Carbon::parse('2025-12-01'),
+        'next_due_date'              => Carbon::parse('2026-01-10'),
+        'next_due_odometer'          => 15000,
+        'next_due_engine_hours'      => 650,
+    ]);
+
+    expect($schedule->isDue(null, null, Carbon::parse('2026-01-11')))->toBeTrue()
+        ->and($schedule->isDue(15000, null, Carbon::parse('2026-01-01')))->toBeTrue()
+        ->and($schedule->isDue(null, 650, Carbon::parse('2026-01-01')))->toBeTrue();
+
+    $schedule->forceFill([
+        'next_due_date'         => Carbon::parse('2026-02-10'),
+        'next_due_odometer'     => 20000,
+        'next_due_engine_hours' => 900,
+    ]);
+
+    expect($schedule->isDue(12000, 500, Carbon::parse('2026-01-15')))->toBeFalse();
+
+    $schedule->status = 'paused';
+    expect($schedule->isDue(25000, 1000, Carbon::parse('2026-03-01')))->toBeFalse();
+
+    $schedule->resetAfterCompletion(16000, 700, Carbon::parse('2026-01-20'));
+    expect($schedule->updates[0]['last_service_odometer'])->toBe(16000)
+        ->and($schedule->updates[0]['last_service_engine_hours'])->toBe(700)
+        ->and($schedule->updates[0]['next_due_date']->toDateString())->toBe('2026-02-19')
+        ->and($schedule->updates[0]['next_due_odometer'])->toBe(21000)
+        ->and($schedule->updates[0]['next_due_engine_hours'])->toBe(950)
+        ->and($schedule->pause())->toBeTrue()
+        ->and($schedule->resume())->toBeTrue()
+        ->and($schedule->complete())->toBeTrue();
+
+    Carbon::setTestNow();
+});
+
+test('warranty accessors coverage limits and transfer guards are stable', function () {
+    Carbon::setTestNow(Carbon::parse('2026-01-15 12:00:00'));
+
+    $warranty = new FleetOpsUpdatingWarrantyFake([
+        'subject_type'  => Asset::class,
+        'subject_uuid'  => 'old-asset-uuid',
+        'provider'      => 'Warranty Co',
+        'start_date'    => Carbon::parse('2026-01-01'),
+        'end_date'      => Carbon::parse('2026-02-10'),
+        'coverage'      => [
+            'parts'      => true,
+            'labor'      => false,
+            'roadside'   => true,
+            'limits'     => ['parts' => 5000],
+            'deductible' => ['parts' => 250],
+        ],
+        'terms'         => ['transferable' => true],
+    ]);
+
+    $warranty->setRelation('subject', (object) ['display_name' => 'Truck 12']);
+    $warranty->setRelation('vendor', (object) ['name' => 'Vendor One']);
+
+    expect($warranty->subject_name)->toBe('Truck 12')
+        ->and($warranty->vendor_name)->toBe('Vendor One')
+        ->and($warranty->is_active)->toBeTrue()
+        ->and($warranty->is_expired)->toBeFalse()
+        ->and($warranty->days_remaining)->toBe(25)
+        ->and($warranty->coverage_summary)->toMatchArray(['parts' => true, 'labor' => false, 'roadside' => true])
+        ->and($warranty->status)->toBe('expiring_soon')
+        ->and($warranty->hasCoverage('parts'))->toBeTrue()
+        ->and($warranty->hasCoverage('labor'))->toBeFalse()
+        ->and($warranty->getCoverageLimit('parts'))->toBe(5000)
+        ->and($warranty->coversAmount('parts', 4000))->toBeTrue()
+        ->and($warranty->coversAmount('parts', 6000))->toBeFalse()
+        ->and($warranty->coversAmount('labor', 100))->toBeFalse()
+        ->and($warranty->getDeductible('parts'))->toBe(250.0)
+        ->and($warranty->isTransferable())->toBeTrue();
+
+    $newSubject = new Asset();
+    $newSubject->forceFill(['uuid' => 'new-asset-uuid']);
+    expect($warranty->transferTo($newSubject))->toBeFalse()
+        ->and($warranty->updates[0])->toMatchArray([
+            'subject_type' => Asset::class,
+            'subject_uuid' => 'new-asset-uuid',
+        ]);
+
+    $expired = new FleetOpsUpdatingWarrantyFake([
+        'start_date' => Carbon::parse('2025-01-01'),
+        'end_date'   => Carbon::parse('2025-12-31'),
+    ]);
+    expect($expired->is_active)->toBeFalse()
+        ->and($expired->is_expired)->toBeTrue()
+        ->and($expired->days_remaining)->toBe(0)
+        ->and($expired->status)->toBe('expired');
+
+    $future = new FleetOpsUpdatingWarrantyFake([
+        'start_date' => Carbon::parse('2026-02-01'),
+    ]);
+    expect($future->is_active)->toBeFalse()
+        ->and($future->status)->toBe('not_started');
+
+    $lifetime = new FleetOpsUpdatingWarrantyFake([
+        'start_date' => Carbon::parse('2026-01-01'),
+        'coverage'   => ['deductible' => 100],
+        'terms'      => [],
+    ]);
+    expect($lifetime->days_remaining)->toBeNull()
+        ->and($lifetime->status)->toBe('active')
+        ->and($lifetime->getDeductible('parts'))->toBe(100.0)
+        ->and($lifetime->isTransferable())->toBeFalse();
+
+    Carbon::setTestNow();
+});
+
+test('service area spatial factories and tracking number light accessors are stable', function () {
+    fleetopsMaintenanceUseInMemoryRelationConnection();
+
+    $point = new Point(1.30, 103.80);
+
+    expect(ServiceArea::createPolygonFromPoint($point, 100))->toBeInstanceOf(Fleetbase\LaravelMysqlSpatial\Types\Polygon::class)
+        ->and(ServiceArea::createMultiPolygonFromPoint($point, 100))->toBeInstanceOf(MultiPolygon::class);
+
+    $serviceArea = new ServiceArea(['status' => null, 'type' => null]);
+    expect($serviceArea->status)->toBeNull()
+        ->and($serviceArea->type)->toBeNull()
+        ->and($serviceArea->toGeosCoordinates())->toBe([])
+        ->and($serviceArea->toGeosLineStrings())->toBe([])
+        ->and($serviceArea->toGeosPolygon())->toBeNull()
+        ->and($serviceArea->asPolygon())->toBeNull();
+
+    $zone = new Zone();
+    expect(Zone::createPolygonFromPoint($point, 100))->toBeInstanceOf(Fleetbase\LaravelMysqlSpatial\Types\Polygon::class)
+        ->and($zone->type)->toBe('zone')
+        ->and($zone->toGeosLineStrings())->toBe([])
+        ->and($zone->toGeosPolygon())->toBeNull();
+
+    $tracking = new class extends TrackingNumber {
+        public array $loaded = [];
+
+        public function load($relations)
+        {
+            $this->loaded[] = $relations;
+
+            return $this;
+        }
+    };
+    $tracking->forceFill(['owner_type' => Asset::class]);
+    $tracking->setRelation('status', (object) [
+        'status'     => 'Order Created',
+        'code'       => 'CREATED',
+        'created_at' => Carbon::parse('2026-01-01 12:00:00'),
+        'complete'   => false,
+    ]);
+
+    expect($tracking->last_status)->toBe('Order Created')
+        ->and($tracking->last_status_code)->toBe('CREATED')
+        ->and($tracking->last_status_updated_at->toDateTimeString())->toBe('2026-01-01 12:00:00')
+        ->and($tracking->last_status_complete)->toBeFalse()
+        ->and($tracking->type)->toBe('asset')
+        ->and($tracking->status())->toBeInstanceOf(HasOne::class)
+        ->and($tracking->statuses())->toBeInstanceOf(HasMany::class)
+        ->and($tracking->order())->toBeInstanceOf(BelongsTo::class)
+        ->and($tracking->entity())->toBeInstanceOf(BelongsTo::class)
+        ->and($tracking->owner())->toBeInstanceOf(MorphTo::class);
+});

package/server/tests/ManifestControllerContractsTest.php

@@ -0,0 +1,310 @@
+<?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\Models\config')) {
+    eval('namespace Fleetbase\Models; function config($key = null, $default = null) { return $key === "fleetbase.connection.db" ? "mysql" : $default; }');
+}
+
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\ManifestController;
+use Fleetbase\FleetOps\Models\Manifest;
+use Fleetbase\FleetOps\Models\ManifestStop;
+use Illuminate\Http\Request;
+
+class FleetOpsManifestControllerProbe extends ManifestController
+{
+    public FleetOpsManifestQueryFake $companyQuery;
+    public FleetOpsManifestQueryFake $manifestQuery;
+    public FleetOpsManifestQueryFake $stopQuery;
+
+    protected function manifestQueryForCompany(?string $companyUuid)
+    {
+        $this->companyQuery = new FleetOpsManifestQueryFake(['company' => $companyUuid]);
+
+        return $this->companyQuery;
+    }
+
+    protected function manifestQueryByPublicId(string $id)
+    {
+        $this->manifestQuery = new FleetOpsManifestQueryFake(['public_id' => $id]);
+
+        return $this->manifestQuery;
+    }
+
+    protected function manifestStopQueryByPublicId(string $id)
+    {
+        $this->stopQuery = new FleetOpsManifestQueryFake(['public_id' => $id], fleetopsManifestStopFake());
+
+        return $this->stopQuery;
+    }
+}
+
+class FleetOpsManifestQueryFake
+{
+    public array $calls = [];
+
+    public function __construct(public array $scope = [], public mixed $record = null)
+    {
+        $this->record = $record ?? fleetopsManifestFake();
+    }
+
+    public function with(array $relations): self
+    {
+        $this->calls[] = ['with', array_keys($relations) === range(0, count($relations) - 1) ? $relations : array_keys($relations)];
+
+        return $this;
+    }
+
+    public function where(string $column, mixed $value): self
+    {
+        $this->calls[] = ['where', $column, $value];
+
+        return $this;
+    }
+
+    public function whereHas(string $relation, Closure $callback): self
+    {
+        $nested = new self();
+        $callback($nested);
+        $this->calls[] = ['whereHas', $relation, $nested->calls];
+
+        return $this;
+    }
+
+    public function whereDate(string $column, mixed $value): self
+    {
+        $this->calls[] = ['whereDate', $column, $value];
+
+        return $this;
+    }
+
+    public function orderByDesc(string $column): self
+    {
+        $this->calls[] = ['orderByDesc', $column];
+
+        return $this;
+    }
+
+    public function paginate(mixed $limit): array
+    {
+        $this->calls[] = ['paginate', $limit];
+
+        return ['items' => [['public_id' => 'manifest_public']], 'limit' => $limit];
+    }
+
+    public function firstOrFail(): mixed
+    {
+        $this->calls[] = ['firstOrFail'];
+
+        return $this->record;
+    }
+}
+
+class FleetOpsManifestFake extends Manifest
+{
+    public bool $cancelledForTest = false;
+    public bool $deletedForTest   = false;
+
+    public function cancel(): self
+    {
+        $this->cancelledForTest = true;
+        $this->setAttribute('status', 'cancelled');
+
+        return $this;
+    }
+
+    public function delete()
+    {
+        $this->deletedForTest = true;
+
+        return true;
+    }
+
+    public function toArray(): array
+    {
+        return $this->getAttributes();
+    }
+}
+
+class FleetOpsManifestStopFake extends ManifestStop
+{
+    public array $updates = [];
+    public array $freshes = [];
+
+    public function markArrived(): self
+    {
+        $this->setAttribute('status', 'arrived');
+
+        return $this;
+    }
+
+    public function markCompleted(): self
+    {
+        $this->setAttribute('status', 'completed');
+
+        return $this;
+    }
+
+    public function markSkipped(): self
+    {
+        $this->setAttribute('status', 'skipped');
+
+        return $this;
+    }
+
+    public function update(array $attributes = [], array $options = []): bool
+    {
+        $this->updates[] = $attributes;
+        $this->setRawAttributes(array_merge($this->getAttributes(), $attributes), true);
+
+        return true;
+    }
+
+    public function fresh($with = [])
+    {
+        $this->freshes[] = $with;
+
+        return $this;
+    }
+
+    public function toArray(): array
+    {
+        return $this->getAttributes();
+    }
+}
+
+function fleetopsManifestFake(): FleetOpsManifestFake
+{
+    $manifest = new FleetOpsManifestFake();
+    $manifest->setRawAttributes(['uuid' => 'manifest-uuid', 'public_id' => 'manifest_public', 'status' => 'active'], true);
+
+    return $manifest;
+}
+
+function fleetopsManifestStopFake(): FleetOpsManifestStopFake
+{
+    $stop = new FleetOpsManifestStopFake();
+    $stop->setRawAttributes(['uuid' => 'stop-uuid', 'public_id' => 'stop_public', 'status' => 'pending'], true);
+
+    return $stop;
+}
+
+test('manifest controller applies index filters and returns paginated results', function () {
+    session(['company' => 'company-uuid']);
+
+    $controller = new FleetOpsManifestControllerProbe();
+    $response   = $controller->index(new Request([
+        'status'         => 'active',
+        'driver_id'      => 'driver_public',
+        'vehicle_id'     => 'vehicle_public',
+        'scheduled_date' => '2026-05-01',
+        'limit'          => 15,
+    ]));
+
+    expect($response->getData(true))->toBe([
+        'items' => [['public_id' => 'manifest_public']],
+        'limit' => 15,
+    ])->and($controller->companyQuery->scope)->toBe(['company' => 'company-uuid'])
+        ->and($controller->companyQuery->calls)->toBe([
+            ['where', 'status', 'active'],
+            ['whereHas', 'driver', [['where', 'public_id', 'driver_public']]],
+            ['whereHas', 'vehicle', [['where', 'public_id', 'vehicle_public']]],
+            ['whereDate', 'scheduled_date', '2026-05-01'],
+            ['orderByDesc', 'created_at'],
+            ['paginate', 15],
+        ]);
+});
+
+test('manifest controller shows cancels destroys and updates stops through status transitions', function () {
+    $controller = new FleetOpsManifestControllerProbe();
+
+    $show    = $controller->show('manifest_public')->getData(true);
+    $cancel  = $controller->cancel('manifest_public')->getData(true);
+    $destroy = $controller->destroy('manifest_public')->getData(true);
+
+    $arrived   = $controller->updateStop(new Request(['status' => 'arrived']), 'stop_public')->getData(true);
+    $completed = $controller->updateStop(new Request(['status' => 'completed']), 'stop_public')->getData(true);
+    $skipped   = $controller->updateStop(new Request(['status' => 'skipped']), 'stop_public')->getData(true);
+    $patched   = $controller->updateStop(new Request(['status' => 'rescheduled', 'sequence' => 4, 'ignored' => true]), 'stop_public')->getData(true);
+
+    expect($show['manifest'])->toMatchArray(['public_id' => 'manifest_public'])
+        ->and($controller->manifestQuery->calls)->toContain(['firstOrFail'])
+        ->and($cancel)->toMatchArray(['status' => 'cancelled'])
+        ->and($destroy)->toBe(['deleted' => true])
+        ->and($arrived['stop']['status'])->toBe('arrived')
+        ->and($completed['stop']['status'])->toBe('completed')
+        ->and($skipped['stop']['status'])->toBe('skipped')
+        ->and($patched['stop'])->toMatchArray(['status' => 'rescheduled', 'sequence' => 4])
+        ->and($controller->stopQuery->record->updates)->toBe([['status' => 'rescheduled', 'sequence' => 4]])
+        ->and($controller->stopQuery->record->freshes[0])->toBe(['place', 'order.trackingNumber']);
+});
+
+test('manifest real query helpers and stop endpoints hit the database', function () {
+    $connection = new Illuminate\Database\SQLiteConnection(new PDO('sqlite::memory:'));
+    $resolver   = new Illuminate\Database\ConnectionResolver(['default' => $connection, 'mysql' => $connection]);
+    $resolver->setDefaultConnection('mysql');
+    Illuminate\Database\Eloquent\Model::setConnectionResolver($resolver);
+    if (!Illuminate\Database\Eloquent\Model::getEventDispatcher()) {
+        Illuminate\Database\Eloquent\Model::setEventDispatcher(new Illuminate\Events\Dispatcher());
+    }
+    $schema = $connection->getSchemaBuilder();
+    $tables = [
+        'manifests'        => ['uuid', 'public_id', 'company_uuid', 'driver_uuid', 'vehicle_uuid', 'status', 'name', 'date', 'meta', '_key'],
+        'manifest_stops'   => ['uuid', 'public_id', 'company_uuid', 'manifest_uuid', 'place_uuid', 'order_uuid', 'waypoint_uuid', 'status', 'sequence', 'notes', 'actual_arrival', 'meta', '_key'],
+        'places'           => ['uuid', 'public_id', 'company_uuid', 'name', 'location', '_key'],
+        'orders'           => ['uuid', 'public_id', 'company_uuid', 'payload_uuid', 'tracking_number_uuid', 'status', 'meta', '_key'],
+        'payloads'         => ['uuid', 'public_id', 'company_uuid', 'pickup_uuid', 'dropoff_uuid', 'meta', '_key'],
+        'tracking_numbers' => ['uuid', 'public_id', 'company_uuid', 'tracking_number', '_key'],
+        'waypoints'        => ['uuid', 'public_id', 'company_uuid', 'payload_uuid', 'place_uuid', 'order', 'type', '_key'],
+        'drivers'          => ['uuid', 'public_id', 'company_uuid', 'user_uuid', '_key'],
+        'vehicles'         => ['uuid', 'public_id', 'company_uuid', 'name', '_key'],
+        'users'            => ['uuid', 'public_id', 'company_uuid', 'name', '_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-mfr-1']);
+    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());
+    $connection->table('manifests')->insert(['uuid' => 'manifest-real-1', 'public_id' => 'manifest_realone', 'company_uuid' => 'company-mfr-1', 'status' => 'active']);
+    $connection->table('manifest_stops')->insert(['uuid' => 'stop-real-1', 'public_id' => 'manifest_stop_realone', 'company_uuid' => 'company-mfr-1', 'manifest_uuid' => 'manifest-real-1', 'place_uuid' => 'place-mfr-1', 'status' => 'pending', 'sequence' => '1', 'meta' => json_encode([])]);
+    $connection->table('places')->insert(['uuid' => 'place-mfr-1', 'company_uuid' => 'company-mfr-1', 'name' => 'Manifest Stop Place']);
+
+    $controller = new ManifestController();
+    $helper     = function (string $method, ...$arguments) use ($controller) {
+        $reflection = new ReflectionMethod(ManifestController::class, $method);
+        $reflection->setAccessible(true);
+
+        return $reflection->invoke($controller, ...$arguments);
+    };
+
+    // Real query helpers scope by company and public ids
+    expect($helper('manifestQueryForCompany', 'company-mfr-1')->count())->toBe(1)
+        ->and($helper('manifestQueryByPublicId', 'manifest_realone')->count())->toBe(1)
+        ->and($helper('manifestStopQueryByPublicId', 'manifest_stop_realone')->count())->toBe(1);
+
+    // showStop loads the stop with its relations
+    $shown = $controller->showStop('manifest_stop_realone')->getData(true);
+    expect($shown['stop']['uuid'])->toBe('stop-real-1');
+
+    // Sequence-only updates persist without status transitions
+    $updated = $controller->updateStop(new Request(['sequence' => 7]), 'manifest_stop_realone')->getData(true);
+    expect((string) $connection->table('manifest_stops')->value('sequence'))->toBe('7');
+});