@fleetbase/fleetops-engine 0.6.58 → 0.6.59

package/server/tests/Unit/Models/VendorRelationsAndImportTest.php

@@ -0,0 +1,107 @@
+<?php
+
+use Fleetbase\FleetOps\Models\Vendor;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+/**
+ * Covers the Vendor relation builders and import creation: connected
+ * company/personnel/order/file relations and place-resolved vendor rows.
+ */
+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 fleetopsVendorModelBoot(): SQLiteConnection
+{
+    $pdo = new PDO('sqlite::memory:');
+    foreach (['ST_PointFromText', 'ST_GeomFromText'] as $fn) {
+        $pdo->sqliteCreateFunction($fn, fn ($wkt, $srid = 0, $axisOrder = null) => $wkt);
+    }
+    $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');
+
+    $schema = $connection->getSchemaBuilder();
+    $schema->create('companies', function ($blueprint) {
+        $blueprint->increments('id');
+        foreach (['uuid', 'public_id', 'name', 'country', 'options'] as $column) {
+            $blueprint->string($column)->nullable();
+        }
+        $blueprint->timestamps();
+        $blueprint->timestamp('deleted_at')->nullable();
+    });
+    $schema->create('vendors', function ($blueprint) {
+        $blueprint->increments('id');
+        foreach (['uuid', 'public_id', 'company_uuid', 'connect_company_uuid', 'place_uuid', 'name', 'email', 'phone', 'address', 'website', 'country', 'type', 'status', 'meta', 'internal_id', 'slug', '_key'] as $column) {
+            $blueprint->string($column)->nullable();
+        }
+        $blueprint->timestamps();
+        $blueprint->timestamp('deleted_at')->nullable();
+    });
+
+    session(['company' => 'company-1']);
+    $connection->table('companies')->insert(['uuid' => 'company-1', 'name' => 'Vendor Co']);
+    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());
+
+    return $connection;
+}
+
+test('vendor relations and imports resolve builders and persist rows', function () {
+    $connection = fleetopsVendorModelBoot();
+
+    $vendor = new Vendor();
+    expect($vendor->company())->toBeInstanceOf(Illuminate\Database\Eloquent\Relations\BelongsTo::class)
+        ->and($vendor->connectCompany())->toBeInstanceOf(Illuminate\Database\Eloquent\Relations\BelongsTo::class)
+        ->and($vendor->vendorPersonnel())->toBeInstanceOf(Illuminate\Database\Eloquent\Relations\HasMany::class)
+        ->and($vendor->personnels())->toBeInstanceOf(Illuminate\Database\Eloquent\Relations\HasManyThrough::class)
+        ->and($vendor->facilitatorOrders())->toBeInstanceOf(Illuminate\Database\Eloquent\Relations\HasMany::class)
+        ->and($vendor->customerOrders())->toBeInstanceOf(Illuminate\Database\Eloquent\Relations\HasMany::class)
+        ->and($vendor->files())->toBeInstanceOf(Illuminate\Database\Eloquent\Relations\HasMany::class);
+
+    // Imports persist vendors and adopt resolved places
+    $place = new Fleetbase\FleetOps\Models\Place();
+    $place->setRawAttributes(['uuid' => 'place-vendor-1', 'public_id' => 'place_vendorone'], true);
+    $place->exists = true;
+
+    $created = Vendor::createFromImport([
+        'name'    => 'Imported Vendor',
+        'phone'   => '+6588881234',
+        'email'   => 'imported@example.test',
+        'website' => 'https://vendor.example.test',
+        'address' => $place,
+    ], true);
+
+    expect($created)->toBeInstanceOf(Vendor::class)
+        ->and($created->place_uuid)->toBe('place-vendor-1')
+        ->and($connection->table('vendors')->count())->toBe(1);
+});

package/server/tests/Unit/Models/WarrantyTest.php

@@ -0,0 +1,187 @@
+<?php
+
+if (!function_exists('Fleetbase\FleetOps\Models\activity')) {
+    eval('namespace Fleetbase\FleetOps\Models; function activity($logName = null) { return new class($logName) {
+        public array $properties = [];
+        public array $logs = [];
+        public function __construct(public ?string $logName = null) {}
+        public function performedOn($subject) { return $this; }
+        public function withProperties(array $properties) { $this->properties = $properties; return $this; }
+        public function log(string $message) { $this->logs[] = $message; return $this; }
+    }; }');
+}
+
+use Fleetbase\FleetOps\Models\Asset;
+use Fleetbase\FleetOps\Models\Vendor;
+use Fleetbase\FleetOps\Models\Warranty;
+use Fleetbase\Models\User;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\MorphTo;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Support\Carbon;
+use Spatie\Activitylog\LogOptions;
+
+class FleetOpsWarrantyQueryFake
+{
+    public array $calls = [];
+
+    public function where($column, $operator = null, $value = null): self
+    {
+        $this->calls[] = ['where', $column, $operator, $value];
+
+        return $this;
+    }
+
+    public function whereNull(string $column): self
+    {
+        $this->calls[] = ['whereNull', $column];
+
+        return $this;
+    }
+
+    public function orWhere($column, $operator = null, $value = null): self
+    {
+        $this->calls[] = ['orWhere', $column, $operator, $value];
+
+        return $this;
+    }
+
+    public function whereNotNull(string $column): self
+    {
+        $this->calls[] = ['whereNotNull', $column];
+
+        return $this;
+    }
+
+    public function whereBetween(string $column, array $range): self
+    {
+        $this->calls[] = ['whereBetween', $column, $range];
+
+        return $this;
+    }
+}
+
+class FleetOpsWarrantyRootQueryFake extends FleetOpsWarrantyQueryFake
+{
+    public function where($column, $operator = null, $value = null): self
+    {
+        if ($column instanceof Closure) {
+            $nested = new FleetOpsWarrantyQueryFake();
+            $column($nested);
+            $this->calls[] = ['whereNested', $nested->calls];
+
+            return $this;
+        }
+
+        return parent::where($column, $operator, $value);
+    }
+}
+
+class FleetOpsSuccessfulWarrantyFake 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 true;
+    }
+}
+
+function fleetopsWarrantyUnitUseInMemoryConnection(): void
+{
+    $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
+    $resolver   = new ConnectionResolver([
+        'default' => $connection,
+        'mysql'   => $connection,
+    ]);
+
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+}
+
+beforeEach(function () {
+    fleetopsWarrantyUnitUseInMemoryConnection();
+    Carbon::setTestNow(Carbon::parse('2026-07-27 12:00:00'));
+});
+
+afterEach(function () {
+    Carbon::setTestNow();
+});
+
+test('warranty relationship contracts activity options and null accessors are stable', function () {
+    $warranty = new Warranty();
+
+    expect($warranty->getActivitylogOptions())->toBeInstanceOf(LogOptions::class)
+        ->and($warranty->vendor())->toBeInstanceOf(BelongsTo::class)
+        ->and($warranty->vendor()->getRelated())->toBeInstanceOf(Vendor::class)
+        ->and($warranty->createdBy())->toBeInstanceOf(BelongsTo::class)
+        ->and($warranty->createdBy()->getRelated())->toBeInstanceOf(User::class)
+        ->and($warranty->updatedBy())->toBeInstanceOf(BelongsTo::class)
+        ->and($warranty->updatedBy()->getRelated())->toBeInstanceOf(User::class)
+        ->and($warranty->subject())->toBeInstanceOf(MorphTo::class)
+        ->and($warranty->subject_name)->toBeNull()
+        ->and($warranty->vendor_name)->toBeNull()
+        ->and((new Warranty())->status)->toBe('pending');
+});
+
+test('warranty scopes write active expired and expiring soon constraints', function () {
+    $warranty = new Warranty();
+
+    $active = new FleetOpsWarrantyRootQueryFake();
+    expect($warranty->scopeActive($active))->toBe($active)
+        ->and($active->calls)->toHaveCount(2)
+        ->and($active->calls[0][0])->toBe('whereNested')
+        ->and($active->calls[0][1][0])->toBe(['whereNull', 'start_date'])
+        ->and($active->calls[0][1][1][0])->toBe('orWhere')
+        ->and($active->calls[0][1][1][1])->toBe('start_date')
+        ->and($active->calls[0][1][1][2])->toBe('<=')
+        ->and($active->calls[1][1][0])->toBe(['whereNull', 'end_date'])
+        ->and($active->calls[1][1][1][0])->toBe('orWhere')
+        ->and($active->calls[1][1][1][1])->toBe('end_date')
+        ->and($active->calls[1][1][1][2])->toBe('>=');
+
+    $expired = new FleetOpsWarrantyRootQueryFake();
+    expect($warranty->scopeExpired($expired))->toBe($expired)
+        ->and($expired->calls[0])->toBe(['whereNotNull', 'end_date'])
+        ->and($expired->calls[1][0])->toBe('where')
+        ->and($expired->calls[1][1])->toBe('end_date')
+        ->and($expired->calls[1][2])->toBe('<');
+
+    $expiringSoon = new FleetOpsWarrantyRootQueryFake();
+    expect($warranty->scopeExpiringSoon($expiringSoon, 45))->toBe($expiringSoon)
+        ->and($expiringSoon->calls[0])->toBe(['whereNotNull', 'end_date'])
+        ->and($expiringSoon->calls[1][0])->toBe('whereBetween')
+        ->and($expiringSoon->calls[1][1])->toBe('end_date')
+        ->and($expiringSoon->calls[1][2][0]->toDateTimeString())->toBe('2026-07-27 12:00:00')
+        ->and($expiringSoon->calls[1][2][1]->toDateTimeString())->toBe('2026-09-10 12:00:00');
+});
+
+test('warranty successful transfer updates subject and logs transfer properties', function () {
+    $warranty = new FleetOpsSuccessfulWarrantyFake([
+        'subject_type' => Asset::class,
+        'subject_uuid' => 'old-asset-uuid',
+        'terms'        => ['transferable' => true],
+    ]);
+
+    $newSubject = new Asset();
+    $newSubject->forceFill(['uuid' => 'new-asset-uuid']);
+
+    expect($warranty->transferTo($newSubject, ['reason' => 'sold']))->toBeTrue()
+        ->and($warranty->updates)->toHaveCount(1)
+        ->and($warranty->updates[0])->toBe([
+            'subject_type' => Asset::class,
+            'subject_uuid' => 'new-asset-uuid',
+        ])
+        ->and($warranty->subject_type)->toBe(Asset::class)
+        ->and($warranty->subject_uuid)->toBe('new-asset-uuid');
+});

package/server/tests/Unit/Models/WaypointTest.php

@@ -0,0 +1,366 @@
+<?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; }');
+}
+
+if (!function_exists('Fleetbase\Traits\app')) {
+    eval('namespace Fleetbase\Traits; function app($abstract = null, array $parameters = []) { return \app($abstract, $parameters); }');
+}
+
+if (!function_exists('Fleetbase\FleetOps\Models\view')) {
+    eval('namespace Fleetbase\FleetOps\Models; function view($name = null, $data = []) { \FleetOpsWaypointViewRecorder::$views[] = [$name, array_keys($data)]; return new class { public function render() { return "<html>waypoint-label</html>"; } }; }');
+}
+
+if (!function_exists('Fleetbase\FleetOps\Models\session')) {
+    eval('namespace Fleetbase\FleetOps\Models; function session($key = null) { return \FleetOpsWaypointSessionStore::get($key); }');
+}
+
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Models\Payload;
+use Fleetbase\FleetOps\Models\Place;
+use Fleetbase\FleetOps\Models\Waypoint;
+use Fleetbase\FleetOps\Support\Utils;
+use Fleetbase\LaravelMysqlSpatial\Types\Point;
+
+class FleetOpsWaypointViewRecorder
+{
+    public static array $views = [];
+}
+
+class FleetOpsWaypointSessionStore
+{
+    public static array $data = [];
+
+    public static function get(?string $key = null): mixed
+    {
+        return $key === null ? static::$data : (static::$data[$key] ?? null);
+    }
+}
+
+class FleetOpsWaypointInsertFake extends Waypoint
+{
+    public static array $insertedValues       = [];
+    public static array $createdTracking      = [];
+    public static array $trackingNumberWrites = [];
+    public static bool $insertResult          = true;
+
+    public static function resetInsertFake(): void
+    {
+        static::$insertedValues       = [];
+        static::$createdTracking      = [];
+        static::$trackingNumberWrites = [];
+        static::$insertResult         = true;
+    }
+
+    public function getFillable()
+    {
+        return array_merge(parent::getFillable(), ['meta']);
+    }
+
+    protected static function newUuid(): string
+    {
+        return 'waypoint-uuid';
+    }
+
+    protected static function newPublicId(): string
+    {
+        return 'waypoint_public';
+    }
+
+    protected static function currentTimestamp(): string
+    {
+        return '2026-08-04 11:22:33';
+    }
+
+    protected static function insertWaypoint(array $values): bool
+    {
+        static::$insertedValues[] = $values;
+
+        return static::$insertResult;
+    }
+
+    protected static function createTrackingNumber(array $values)
+    {
+        static::$createdTracking[] = $values;
+
+        return 'tracking-uuid';
+    }
+
+    protected static function pickupLocationWkt(Payload $payload): string
+    {
+        return 'POINT(55.2708 25.2048)';
+    }
+
+    protected static function updateTrackingNumberUuid(string $uuid, mixed $trackingNumberId): void
+    {
+        static::$trackingNumberWrites[] = [$uuid, $trackingNumberId];
+    }
+}
+
+class FleetOpsWaypointPayloadFake extends Payload
+{
+    public function getPickupRegion(): string
+    {
+        return 'AE';
+    }
+
+    public function getPickupLocation()
+    {
+        return new Point(25.2048, 55.2708);
+    }
+}
+
+class FleetOpsWaypointQueryFake
+{
+    public array $calls = [];
+
+    public function __construct(public ?Waypoint $result = null)
+    {
+    }
+
+    public function select(array $columns): self
+    {
+        $this->calls[] = ['select', $columns];
+
+        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 first(): ?Waypoint
+    {
+        $this->calls[] = ['first'];
+
+        return $this->result;
+    }
+}
+
+class FleetOpsWaypointFindFake extends Waypoint
+{
+    public static ?FleetOpsWaypointQueryFake $query = null;
+    public static array $withCalls                  = [];
+
+    public static function resetFindFake(?Waypoint $result = null): void
+    {
+        static::$query     = new FleetOpsWaypointQueryFake($result);
+        static::$withCalls = [];
+    }
+
+    public static function with($relations)
+    {
+        static::$withCalls[] = $relations;
+
+        return static::$query;
+    }
+}
+
+beforeEach(function () {
+    FleetOpsWaypointInsertFake::resetInsertFake();
+    FleetOpsWaypointFindFake::resetFindFake(new FleetOpsWaypointFindFake());
+    FleetOpsWaypointSessionStore::$data = [];
+});
+
+test('waypoint insert filters values and creates payload tracking number', function () {
+    FleetOpsWaypointSessionStore::$data = [
+        'api_key' => 'api-key-uuid',
+        'company' => 'company-uuid',
+    ];
+
+    $payload = new FleetOpsWaypointPayloadFake();
+    $payload->setRawAttributes(['uuid' => 'payload-uuid'], true);
+
+    $uuid = FleetOpsWaypointInsertFake::insertGetUuid([
+        'place_uuid'   => 'place-uuid',
+        'type'         => 'dropoff',
+        'order'        => 2,
+        'meta'         => ['source' => 'api'],
+        'not_allowed'  => 'ignored',
+        'pod_required' => true,
+    ], $payload);
+
+    expect($uuid)->toBe('waypoint-uuid')
+        ->and(FleetOpsWaypointInsertFake::$insertedValues)->toHaveCount(1);
+
+    $inserted = FleetOpsWaypointInsertFake::$insertedValues[0];
+
+    expect($inserted)->toMatchArray([
+        'uuid'         => 'waypoint-uuid',
+        'public_id'    => 'waypoint_public',
+        '_key'         => 'api-key-uuid',
+        'created_at'   => '2026-08-04 11:22:33',
+        'company_uuid' => 'company-uuid',
+        'payload_uuid' => 'payload-uuid',
+        'place_uuid'   => 'place-uuid',
+        'type'         => 'dropoff',
+        'order'        => 2,
+        'meta'         => '{"source":"api"}',
+        'pod_required' => true,
+    ])->and($inserted)->not->toHaveKey('not_allowed')
+        ->and(FleetOpsWaypointInsertFake::$createdTracking)->toHaveCount(1)
+        ->and(FleetOpsWaypointInsertFake::$createdTracking[0])->toMatchArray([
+            'owner_uuid' => 'waypoint-uuid',
+            'owner_type' => Utils::getModelClassName('waypoint'),
+            'region'     => 'AE',
+        ])
+        ->and(FleetOpsWaypointInsertFake::$createdTracking[0]['location'])->toBe('POINT(55.2708 25.2048)')
+        ->and(FleetOpsWaypointInsertFake::$trackingNumberWrites)->toBe([
+            ['waypoint-uuid', 'tracking-uuid'],
+        ]);
+});
+
+test('waypoint insert skips payload side effects when insert fails', function () {
+    FleetOpsWaypointInsertFake::$insertResult = false;
+
+    $payload = new FleetOpsWaypointPayloadFake();
+    $payload->setRawAttributes(['uuid' => 'payload-uuid'], true);
+
+    expect(FleetOpsWaypointInsertFake::insertGetUuid(['place_uuid' => 'place-uuid'], $payload))->toBeFalse()
+        ->and(FleetOpsWaypointInsertFake::$insertedValues)->toHaveCount(1)
+        ->and(FleetOpsWaypointInsertFake::$createdTracking)->toBe([])
+        ->and(FleetOpsWaypointInsertFake::$trackingNumberWrites)->toBe([]);
+});
+
+test('waypoint find by place scopes lookups by payload and place identity', function () {
+    $result = new FleetOpsWaypointFindFake();
+    FleetOpsWaypointFindFake::resetFindFake($result);
+
+    $order = new Order();
+    $order->setRawAttributes(['payload_uuid' => 'payload-uuid'], true);
+
+    $place = new Place();
+    $place->setRawAttributes(['uuid' => 'place-uuid'], true);
+
+    expect(FleetOpsWaypointFindFake::findByPlace($place, $order, ['place'], ['uuid']))->toBe($result)
+        ->and(FleetOpsWaypointFindFake::$withCalls)->toBe([['place']])
+        ->and(FleetOpsWaypointFindFake::$query->calls)->toBe([
+            ['select', ['uuid']],
+            ['where', 'payload_uuid', 'payload-uuid'],
+            ['where', 'place_uuid', 'place-uuid'],
+            ['first'],
+        ]);
+
+    FleetOpsWaypointFindFake::resetFindFake($result);
+
+    $payload = new Payload();
+    $payload->setRawAttributes(['uuid' => 'payload-uuid'], true);
+    $uuidPlace = '11111111-1111-4111-8111-111111111111';
+
+    expect(FleetOpsWaypointFindFake::findByPlace($uuidPlace, $payload))->toBe($result)
+        ->and(FleetOpsWaypointFindFake::$query->calls)->toBe([
+            ['select', ['*']],
+            ['where', 'payload_uuid', 'payload-uuid'],
+            ['where', 'place_uuid', $uuidPlace],
+            ['first'],
+        ]);
+
+    FleetOpsWaypointFindFake::resetFindFake($result);
+
+    expect(FleetOpsWaypointFindFake::findByPlace('place_public', $payload))->toBe($result)
+        ->and(FleetOpsWaypointFindFake::$query->calls)->toBe([
+            ['select', ['*']],
+            ['where', 'payload_uuid', 'payload-uuid'],
+            ['whereHas', 'place', [
+                ['where', 'public_id', 'place_public'],
+            ]],
+            ['first'],
+        ]);
+});
+
+test('waypoint find by place requires an order payload uuid', function () {
+    $order = new Order();
+    $place = new Place();
+    $place->setRawAttributes(['uuid' => 'place-uuid'], true);
+
+    expect(fn () => FleetOpsWaypointFindFake::findByPlace($place, $order))
+        ->toThrow(InvalidArgumentException::class, 'Missing payload UUID for lookup.');
+});
+
+test('waypoint labels render views and stream pdf output', 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);
+    $schema = $connection->getSchemaBuilder();
+    $tables = [
+        'waypoints'        => ['uuid', 'public_id', 'company_uuid', 'payload_uuid', 'place_uuid', 'tracking_number_uuid', 'order', 'type', 'status', '_key'],
+        'places'           => ['uuid', 'public_id', 'company_uuid', 'name', 'location', '_key'],
+        'entities'         => ['uuid', 'public_id', 'company_uuid', 'payload_uuid', 'destination_uuid', 'name', 'type', '_key'],
+        'tracking_numbers' => ['uuid', 'public_id', 'company_uuid', 'tracking_number', 'owner_uuid', 'owner_type', '_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) {
+                $blueprint->string($column)->nullable();
+            }
+            $blueprint->timestamps();
+            $blueprint->timestamp('deleted_at')->nullable();
+        });
+    }
+
+    $connection->table('waypoints')->insert(['uuid' => 'waypoint-label-1', 'company_uuid' => 'company-1', 'payload_uuid' => 'payload-1', 'place_uuid' => 'place-1', 'tracking_number_uuid' => 'tn-1']);
+    $connection->table('places')->insert(['uuid' => 'place-1', 'company_uuid' => 'company-1', 'name' => 'Label Stop']);
+    $connection->table('entities')->insert(['uuid' => 'entity-1', 'company_uuid' => 'company-1', 'payload_uuid' => 'payload-1', 'destination_uuid' => 'place-1', 'name' => 'Boxed Goods']);
+    $connection->table('tracking_numbers')->insert(['uuid' => 'tn-1', 'company_uuid' => 'company-1', 'tracking_number' => 'FLB-LABEL-1']);
+    $connection->table('companies')->insert(['uuid' => 'company-1', 'name' => 'Label Co']);
+
+    $waypoint = Waypoint::where('uuid', 'waypoint-label-1')->first();
+
+    // The label view renders with the waypoint context
+    FleetOpsWaypointViewRecorder::$views = [];
+    expect($waypoint->label())->toBe('<html>waypoint-label</html>')
+        ->and(FleetOpsWaypointViewRecorder::$views[0][0])->toBe('fleetops::labels/waypoint-label')
+        ->and(FleetOpsWaypointViewRecorder::$views[0][1])->toContain('waypoint', 'dropoff', 'entities', 'trackingNumber', 'company');
+
+    // Entities scope to the waypoint payload and destination place
+    expect($waypoint->entities()->count())->toBe(1);
+
+    // Pdf labels load through the shared renderer and stream output
+    $wrapper = new class {
+        public array $loadedHtml = [];
+
+        public function loadHTML(string $html, ?string $encoding = null): self
+        {
+            $this->loadedHtml[] = [$html, $encoding];
+
+            return $this;
+        }
+
+        public function stream()
+        {
+            return 'pdf-stream';
+        }
+
+        public function __call($method, $arguments)
+        {
+            return $this;
+        }
+    };
+    Illuminate\Container\Container::getInstance()->instance('dompdf.wrapper', $wrapper);
+    app()->instance('dompdf.wrapper', $wrapper);
+    Barryvdh\DomPDF\Facade\Pdf::clearResolvedInstance('dompdf.wrapper');
+
+    expect($waypoint->pdfLabel())->toBe($wrapper)
+        ->and($waypoint->pdfLabelStream())->toBe('pdf-stream');
+});