@fleetbase/fleetops-engine 0.6.58 → 0.6.59

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

@@ -0,0 +1,115 @@
+<?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\Models\Vehicle;
+use Fleetbase\FleetOps\Models\VehicleDevice;
+use Fleetbase\FleetOps\Models\VehicleDeviceEvent;
+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\SQLiteConnection;
+
+class FleetOpsVehicleDeviceModelDatabaseProbe
+{
+    public function __construct(private SQLiteConnection $connection)
+    {
+    }
+
+    public function connection(): SQLiteConnection
+    {
+        return $this->connection;
+    }
+
+    public function raw(string $value)
+    {
+        return $this->connection->raw($value);
+    }
+}
+
+class FleetOpsVehicleDeviceModelProbe extends VehicleDevice
+{
+    public array $loaded = [];
+
+    public function load($relations)
+    {
+        $this->loaded[] = $relations;
+
+        return $this;
+    }
+}
+
+function fleetopsVehicleDeviceModelUseInMemoryConnection(): SQLiteConnection
+{
+    $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
+    $connection->statement('create table vehicles (
+        id integer primary key autoincrement,
+        uuid varchar(64),
+        public_id varchar(64) null,
+        name varchar(64) null,
+        deleted_at datetime null
+    )');
+
+    $resolver = new ConnectionResolver([
+        'default' => $connection,
+        'mysql'   => $connection,
+    ]);
+
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+    app()->instance('db', new FleetOpsVehicleDeviceModelDatabaseProbe($connection));
+
+    return $connection;
+}
+
+test('vehicle device relationships point to vehicles and device events', function () {
+    fleetopsVehicleDeviceModelUseInMemoryConnection();
+
+    $device = new VehicleDevice();
+
+    expect($device->vehicle())->toBeInstanceOf(BelongsTo::class)
+        ->and($device->vehicle()->getRelated())->toBeInstanceOf(Vehicle::class)
+        ->and($device->events())->toBeInstanceOf(HasMany::class)
+        ->and($device->events()->getRelated())->toBeInstanceOf(VehicleDeviceEvent::class);
+});
+
+test('vehicle device resolves loaded vehicles persisted vehicles and callback hooks', function () {
+    $connection = fleetopsVehicleDeviceModelUseInMemoryConnection();
+    $connection->table('vehicles')->insert([
+        'uuid'      => 'vehicle-uuid',
+        'public_id' => 'vehicle_public',
+        'name'      => 'Truck 9',
+    ]);
+
+    $loadedVehicle = new Vehicle();
+    $loadedVehicle->setRawAttributes(['uuid' => 'loaded-vehicle'], true);
+
+    $loadedDevice = new FleetOpsVehicleDeviceModelProbe();
+    $loadedDevice->setRelation('vehicle', $loadedVehicle);
+
+    $callbackVehicle = null;
+    expect($loadedDevice->getVehicle(function (Vehicle $vehicle) use (&$callbackVehicle): void {
+        $callbackVehicle = $vehicle;
+    }))->toBe($loadedVehicle)
+        ->and($callbackVehicle)->toBe($loadedVehicle)
+        ->and($loadedDevice->loaded)->toBe([['vehicle']]);
+
+    $queriedDevice = new FleetOpsVehicleDeviceModelProbe();
+    $queriedDevice->setRawAttributes(['vehicle_uuid' => 'vehicle-uuid'], true);
+
+    $queriedVehicle = $queriedDevice->getVehicle(null);
+
+    expect($queriedVehicle)->toBeInstanceOf(Vehicle::class)
+        ->and($queriedVehicle->uuid)->toBe('vehicle-uuid')
+        ->and($queriedVehicle->name)->toBe('Truck 9');
+
+    $missingDevice = new FleetOpsVehicleDeviceModelProbe();
+    expect($missingDevice->getVehicle(null))->toBeNull();
+});

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

@@ -0,0 +1,220 @@
+<?php
+
+if (!function_exists('Fleetbase\Support\session')) {
+    eval('namespace Fleetbase\Support; function session($key = null, $default = null) { if ($key === null) { return new class { public function has($k) { return \session($k) !== null; } public function get($k, $d = null) { return \session($k, $d); } }; } return \session($key, $default); }');
+}
+
+if (!defined('FLEETOPS_VEHICLE_TEST_SERVER_PATH')) {
+    define('FLEETOPS_VEHICLE_TEST_SERVER_PATH', dirname(__DIR__, 3));
+}
+
+if (!function_exists('Fleetbase\FleetOps\Support\base_path')) {
+    eval('namespace Fleetbase\FleetOps\Support; function base_path($path = \'\') { $path = (string) $path; $marker = \'vendor/fleetbase/fleetops-api/server/\'; if (str_contains($path, $marker)) { return FLEETOPS_VEHICLE_TEST_SERVER_PATH . \'/\' . substr($path, strpos($path, $marker) + strlen($marker)); } return rtrim(dirname(FLEETOPS_VEHICLE_TEST_SERVER_PATH) . \'/\' . ltrim($path, \'/\'), \'/\'); }');
+}
+
+if (!function_exists('Fleetbase\Support\auth')) {
+    eval('namespace Fleetbase\Support; function auth() { return new class { public function user() { return null; } public function id() { return null; } }; }');
+}
+
+use Fleetbase\FleetOps\Models\Position;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\LaravelMysqlSpatial\Types\Point;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+/**
+ * Covers Vehicle avatar resolution, position creation with order context
+ * and movement thresholds, attribute-normalized position creation with
+ * destinations, and import-row creation with vehicle-name parsing and
+ * driver assignment against SQLite.
+ */
+function fleetopsVehiclePositionBoot(): SQLiteConnection
+{
+    $pdo = new PDO('sqlite::memory:');
+    // Store points as WKB so spatial casts can rehydrate them on read
+    $pdo->sqliteCreateFunction('ST_PointFromText', function ($wkt, $srid = 0, $axisOrder = null) {
+        if (is_string($wkt) && sscanf($wkt, 'POINT(%f %f)', $lng, $lat) === 2) {
+            return pack('V', 0) . pack('C', 1) . pack('V', 1) . pack('d', $lng) . pack('d', $lat);
+        }
+
+        return $wkt;
+    });
+    $pdo->sqliteCreateFunction('ST_GeomFromText', function ($wkt, $srid = 0, $axisOrder = null) {
+        if (is_string($wkt) && sscanf($wkt, 'POINT(%f %f)', $lng, $lat) === 2) {
+            return pack('V', 0) . pack('C', 1) . pack('V', 1) . pack('d', $lng) . pack('d', $lat);
+        }
+
+        return $wkt;
+    });
+    $connection = new SQLiteConnection($pdo);
+    $resolver   = new ConnectionResolver(['default' => $connection, 'mysql' => $connection]);
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+    app()->instance('db', new class($connection) {
+        public function __construct(public SQLiteConnection $c)
+        {
+        }
+
+        public function connection($name = null): SQLiteConnection
+        {
+            return $this->c;
+        }
+
+        public function __call($method, $arguments)
+        {
+            return $this->c->{$method}(...$arguments);
+        }
+    });
+    Illuminate\Support\Facades\DB::clearResolvedInstance('db');
+
+    $schema = $connection->getSchemaBuilder();
+    $tables = [
+        'vehicles'  => ['uuid', 'public_id', 'internal_id', 'company_uuid', 'name', 'make', 'model', 'year', 'trim', 'plate_number', 'vin', 'serial_number', 'call_sign', 'fuel_card_number', 'type', 'status', 'online', 'location', 'meta', 'avatar_url', '_key'],
+        'positions' => ['uuid', 'public_id', 'company_uuid', 'subject_uuid', 'subject_type', 'destination_uuid', 'coordinates', 'heading', 'bearing', 'speed', 'altitude', 'order_uuid', '_key'],
+        'drivers'   => ['uuid', 'public_id', 'company_uuid', 'user_uuid', 'vehicle_uuid', 'current_job_uuid', 'location', 'online', 'status', '_key'],
+        'users'     => ['uuid', 'public_id', 'company_uuid', 'name', 'type', 'status'],
+        'orders'    => ['uuid', 'public_id', 'company_uuid', 'payload_uuid', 'driver_assigned_uuid', 'status', 'type', 'dispatched', 'started'],
+        'payloads'  => ['uuid', 'public_id', 'company_uuid', 'pickup_uuid', 'dropoff_uuid', 'current_waypoint_uuid', 'type', 'meta', '_key'],
+        'places'    => ['uuid', 'public_id', 'company_uuid', 'name', 'location', 'meta', 'type'],
+        'waypoints' => ['uuid', 'public_id', 'company_uuid', 'payload_uuid', 'place_uuid', 'order', 'type'],
+        'entities'  => ['uuid', 'public_id', 'company_uuid', 'payload_uuid', 'destination_uuid', 'name', 'type'],
+        'files'     => ['uuid', 'public_id', 'company_uuid', 'name', 'path', 'disk', 'bucket', 'type'],
+        'companies' => ['uuid', 'public_id', 'name', 'country'],
+    ];
+    foreach ($tables as $table => $columns) {
+        $schema->create($table, function ($blueprint) use ($columns) {
+            $blueprint->increments('id');
+            foreach ($columns as $column) {
+                if (in_array($column, ['online', 'dispatched', 'started'], true)) {
+                    $blueprint->integer($column)->nullable();
+                    continue;
+                }
+                $blueprint->string($column)->nullable();
+            }
+            $blueprint->timestamps();
+            $blueprint->timestamp('deleted_at')->nullable();
+        });
+    }
+
+    session(['company' => 'company-1']);
+    $connection->table('companies')->insert(['uuid' => 'company-1', 'name' => 'Acme', 'country' => 'SG']);
+
+    return $connection;
+}
+
+function fleetopsVehiclePositionWkb(float $lat, float $lng): string
+{
+    return pack('V', 0) . pack('C', 1) . pack('V', 1) . pack('d', $lng) . pack('d', $lat);
+}
+
+test('avatar urls resolve uuid keys through file lookups', function () {
+    $connection = fleetopsVehiclePositionBoot();
+
+    $vehicle = new Vehicle();
+    $vehicle->setRawAttributes(['avatar_url' => 'https://cdn.example.com/van.png'], true);
+    expect($vehicle->avatar_url)->toBe('https://cdn.example.com/van.png');
+
+    $byUuid = new Vehicle();
+    $byUuid->setRawAttributes(['avatar_url' => '99999999-9999-4999-8999-999999999999'], true);
+    expect($byUuid->avatar_url)->toBeNull()
+        ->and(Vehicle::getAvatar('88888888-8888-4888-8888-888888888888'))->toBeNull();
+
+    // A stored file on a non-local disk hands back its url directly. The disk is
+    // a real FilesystemAdapter so `url()` runs its own path composition.
+    $adapter = new Illuminate\Filesystem\FilesystemAdapter(
+        new League\Flysystem\Filesystem(new League\Flysystem\Local\LocalFilesystemAdapter(sys_get_temp_dir())),
+        new League\Flysystem\Local\LocalFilesystemAdapter(sys_get_temp_dir()),
+        ['url' => 'https://cdn.example.com']
+    );
+    app()->instance('filesystem', new class($adapter) {
+        public function __construct(public $adapter)
+        {
+        }
+
+        public function disk($disk = null)
+        {
+            return $this->adapter;
+        }
+
+        public function __call($method, $arguments)
+        {
+            return $this->adapter->{$method}(...$arguments);
+        }
+    });
+    Illuminate\Support\Facades\Storage::clearResolvedInstance('filesystem');
+
+    $connection->table('files')->insert([
+        'uuid'         => '77777777-7777-4777-8777-777777777777',
+        'public_id'    => 'file_vehicleavatar',
+        'company_uuid' => 'company-1',
+        'disk'         => 'public',
+        'path'         => 'uploads/vehicle-avatar.png',
+    ]);
+
+    expect(Vehicle::getAvatar('77777777-7777-4777-8777-777777777777'))
+        ->toBe('https://cdn.example.com/uploads/vehicle-avatar.png');
+
+    app()->forgetInstance('filesystem');
+    Illuminate\Support\Facades\Storage::clearResolvedInstance('filesystem');
+});
+
+test('position creation with order context respects movement thresholds', function () {
+    $connection = fleetopsVehiclePositionBoot();
+    $connection->table('places')->insert(['uuid' => '11111111-1111-4111-8111-111111111111', 'public_id' => 'place_vehpos1', 'company_uuid' => 'company-1', 'name' => 'Pickup', 'location' => fleetopsVehiclePositionWkb(1.30, 103.80)]);
+    $connection->table('payloads')->insert(['uuid' => 'payload-1', 'company_uuid' => 'company-1', 'pickup_uuid' => '11111111-1111-4111-8111-111111111111']);
+    $connection->table('users')->insert(['uuid' => 'user-1', 'company_uuid' => 'company-1', 'type' => 'user']);
+    $connection->table('drivers')->insert(['uuid' => 'driver-1', 'public_id' => 'driver_vehpos1', 'company_uuid' => 'company-1', 'user_uuid' => 'user-1', 'vehicle_uuid' => 'vehicle-1']);
+    $connection->table('orders')->insert(['uuid' => 'order-1', 'public_id' => 'order_vehpos1', 'company_uuid' => 'company-1', 'payload_uuid' => 'payload-1', 'driver_assigned_uuid' => 'driver-1', 'status' => 'created']);
+    $connection->table('vehicles')->insert(['uuid' => 'vehicle-1', 'public_id' => 'vehicle_vehpos1', 'company_uuid' => 'company-1', 'location' => fleetopsVehiclePositionWkb(1.32, 103.82)]);
+
+    $vehicle = Vehicle::query()->where('uuid', 'vehicle-1')->first();
+    $order   = Fleetbase\FleetOps\Models\Order::query()->where('uuid', 'order-1')->first();
+
+    $first = $vehicle->createPositionWithOrderContext($order);
+    expect($first)->toBeInstanceOf(Position::class)
+        ->and($connection->table('positions')->count())->toBe(1)
+        ->and($connection->table('positions')->value('order_uuid'))->toBe('order-1')
+        ->and($connection->table('positions')->value('destination_uuid'))->toBe('11111111-1111-4111-8111-111111111111');
+
+    // Unmoved vehicles skip creating a second position
+    $vehicle = Vehicle::query()->where('uuid', 'vehicle-1')->first();
+    expect($vehicle->createPositionWithOrderContext($order))->toBeNull()
+        ->and($connection->table('positions')->count())->toBe(1);
+});
+
+test('create position normalizes coordinates and destinations', function () {
+    $connection = fleetopsVehiclePositionBoot();
+    $connection->table('vehicles')->insert(['uuid' => 'vehicle-1', 'public_id' => 'vehicle_vehpos2', 'company_uuid' => 'company-1']);
+    $vehicle = Vehicle::query()->where('uuid', 'vehicle-1')->first();
+
+    $fromLocation = $vehicle->createPosition(['location' => new Point(1.31, 103.81), 'speed' => '12']);
+    expect($fromLocation)->toBeInstanceOf(Position::class);
+
+    $fromLatLng = $vehicle->createPosition(['latitude' => 1.33, 'longitude' => 103.83], '22222222-2222-4222-8222-222222222222');
+    expect($fromLatLng)->toBeInstanceOf(Position::class)
+        ->and($connection->table('positions')->count())->toBe(2)
+        ->and($connection->table('positions')->orderByDesc('id')->value('destination_uuid'))->toBe('22222222-2222-4222-8222-222222222222');
+});
+
+test('import rows parse vehicle names and assign resolved drivers', function () {
+    $connection = fleetopsVehiclePositionBoot();
+    $connection->table('users')->insert(['uuid' => 'user-1', 'company_uuid' => 'company-1', 'name' => 'Casey Driver', 'type' => 'user']);
+    $connection->table('drivers')->insert(['uuid' => 'driver-1', 'public_id' => 'driver_vehimp1', 'company_uuid' => 'company-1', 'user_uuid' => 'user-1']);
+
+    $parsed = Vehicle::createFromImport([
+        'vehicle'      => 'Toyota Hiace 2020',
+        'plate_number' => 'SGV5678B',
+    ], true);
+    expect($parsed)->toBeInstanceOf(Vehicle::class)
+        ->and($parsed->plate_number)->toBe('SGV5678B')
+        ->and($connection->table('vehicles')->count())->toBeGreaterThanOrEqual(1);
+
+    $withDriver = Vehicle::createFromImport([
+        'make'   => 'Ford',
+        'model'  => 'Transit',
+        'driver' => 'driver_vehimp1',
+    ]);
+    expect($withDriver)->toBeInstanceOf(Vehicle::class)
+        ->and($connection->table('drivers')->where('uuid', 'driver-1')->value('vehicle_uuid'))->toBe($withDriver->uuid);
+});

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

@@ -0,0 +1,266 @@
+<?php
+
+if (!function_exists('Fleetbase\FleetOps\Models\session')) {
+    eval('namespace Fleetbase\FleetOps\Models; function session($key = null, $default = null) { return $key === "company" ? "company-vehicle" : $default; }');
+}
+
+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\FleetOps\Support\base_path')) {
+    eval('namespace Fleetbase\FleetOps\Support; function base_path($path = "") { return getcwd() . "/" . str_replace("vendor/fleetbase/fleetops-api/", "", $path); }');
+}
+
+use Fleetbase\FleetOps\Models\Device;
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\Equipment;
+use Fleetbase\FleetOps\Models\Fleet;
+use Fleetbase\FleetOps\Models\Maintenance;
+use Fleetbase\FleetOps\Models\Part;
+use Fleetbase\FleetOps\Models\Position;
+use Fleetbase\FleetOps\Models\Sensor;
+use Fleetbase\FleetOps\Models\Telematic;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Models\Vendor;
+use Fleetbase\FleetOps\Models\Warranty;
+use Fleetbase\Models\Category;
+use Fleetbase\Models\File;
+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\HasManyThrough;
+use Illuminate\Database\Eloquent\Relations\HasOne;
+use Illuminate\Database\Eloquent\Relations\MorphMany;
+use Illuminate\Database\SQLiteConnection;
+
+class FleetOpsVehicleModelDatabaseProbe
+{
+    public function __construct(private SQLiteConnection $connection)
+    {
+    }
+
+    public function connection(): SQLiteConnection
+    {
+        return $this->connection;
+    }
+
+    public function raw(string $value)
+    {
+        return $this->connection->raw($value);
+    }
+}
+
+class FleetOpsVehicleModelAssignableDriverFake extends Driver
+{
+    public ?Vehicle $assignedVehicle = null;
+
+    public function assignVehicle(Vehicle $vehicle): Driver
+    {
+        $this->assignedVehicle = $vehicle;
+
+        return $this;
+    }
+}
+
+class FleetOpsVehicleModelFindQueryFake
+{
+    public array $calls = [];
+
+    public function where(...$arguments): static
+    {
+        $this->calls[] = ['where', $arguments];
+
+        return $this;
+    }
+
+    public function orWhere(...$arguments): static
+    {
+        $this->calls[] = ['orWhere', $arguments];
+
+        return $this;
+    }
+
+    public function orWhereRaw(string $sql, array $bindings = []): static
+    {
+        $this->calls[] = ['orWhereRaw', $sql, $bindings];
+
+        return $this;
+    }
+}
+
+class FleetOpsVehicleModelFindResultFake
+{
+    public function __construct(public ?Vehicle $result, public FleetOpsVehicleModelFindQueryFake $query)
+    {
+    }
+
+    public function first(): ?Vehicle
+    {
+        return $this->result;
+    }
+}
+
+class FleetOpsVehicleModelFindableFake extends Vehicle
+{
+    public static ?FleetOpsVehicleModelFindQueryFake $lastQuery = null;
+    public static ?Vehicle $result                              = null;
+
+    public static function where($column, $operator = null, $value = null, $boolean = 'and')
+    {
+        $query = new FleetOpsVehicleModelFindQueryFake();
+
+        if (is_callable($column)) {
+            $column($query);
+        }
+
+        self::$lastQuery = $query;
+
+        return new FleetOpsVehicleModelFindResultFake(self::$result, $query);
+    }
+}
+
+function fleetopsVehicleModelUseInMemoryConnection(): 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 FleetOpsVehicleModelDatabaseProbe($connection));
+    app()->instance('db.schema', $connection->getSchemaBuilder());
+
+    $schema = $connection->getSchemaBuilder();
+    $schema->create('drivers', function ($table) {
+        $table->increments('id');
+        $table->string('user_uuid')->nullable();
+        $table->string('vehicle_uuid')->nullable();
+        $table->timestamp('created_at')->nullable();
+        $table->timestamp('updated_at')->nullable();
+        $table->timestamp('deleted_at')->nullable();
+    });
+    $schema->create('users', function ($table) {
+        $table->increments('id');
+        $table->string('uuid')->nullable();
+        $table->timestamp('deleted_at')->nullable();
+    });
+    $schema->create('files', function ($table) {
+        $table->increments('id');
+        $table->string('uuid')->nullable();
+        $table->string('url')->nullable();
+        $table->string('type')->nullable();
+        $table->string('original_filename')->nullable();
+        $table->timestamp('deleted_at')->nullable();
+    });
+
+    return $connection;
+}
+
+test('vehicle model exposes relation builders and options', function () {
+    fleetopsVehicleModelUseInMemoryConnection();
+
+    $vehicle = new Vehicle();
+
+    expect($vehicle->getActivitylogOptions()->logOnlyDirty)->toBeTrue()
+        ->and($vehicle->getSlugOptions()->generateSlugFrom)->toBe(['year', 'make', 'model', 'trim', 'plate_number'])
+        ->and($vehicle->getSlugOptions()->slugField)->toBe('slug')
+        ->and($vehicle->photo())->toBeInstanceOf(BelongsTo::class)
+        ->and($vehicle->photo()->getRelated())->toBeInstanceOf(File::class)
+        ->and($vehicle->driver())->toBeInstanceOf(HasOne::class)
+        ->and($vehicle->driver()->getRelated())->toBeInstanceOf(Driver::class)
+        ->and($vehicle->category())->toBeInstanceOf(BelongsTo::class)
+        ->and($vehicle->category()->getRelated())->toBeInstanceOf(Category::class)
+        ->and($vehicle->telematic())->toBeInstanceOf(BelongsTo::class)
+        ->and($vehicle->telematic()->getRelated())->toBeInstanceOf(Telematic::class)
+        ->and($vehicle->warranty())->toBeInstanceOf(BelongsTo::class)
+        ->and($vehicle->warranty()->getRelated())->toBeInstanceOf(Warranty::class)
+        ->and($vehicle->vendor())->toBeInstanceOf(BelongsTo::class)
+        ->and($vehicle->vendor()->getRelated())->toBeInstanceOf(Vendor::class)
+        ->and($vehicle->fleets())->toBeInstanceOf(HasManyThrough::class)
+        ->and($vehicle->fleets()->getRelated())->toBeInstanceOf(Fleet::class)
+        ->and($vehicle->devices())->toBeInstanceOf(HasMany::class)
+        ->and($vehicle->devices()->getRelated())->toBeInstanceOf(Device::class)
+        ->and($vehicle->positions())->toBeInstanceOf(HasMany::class)
+        ->and($vehicle->positions()->getRelated())->toBeInstanceOf(Position::class)
+        ->and($vehicle->equipments())->toBeInstanceOf(HasMany::class)
+        ->and($vehicle->equipments()->getRelated())->toBeInstanceOf(Equipment::class)
+        ->and($vehicle->maintenances())->toBeInstanceOf(HasMany::class)
+        ->and($vehicle->maintenances()->getRelated())->toBeInstanceOf(Maintenance::class)
+        ->and($vehicle->sensors())->toBeInstanceOf(HasMany::class)
+        ->and($vehicle->sensors()->getRelated())->toBeInstanceOf(Sensor::class)
+        ->and($vehicle->parts())->toBeInstanceOf(MorphMany::class)
+        ->and($vehicle->parts()->getRelated())->toBeInstanceOf(Part::class);
+});
+
+test('vehicle avatar helpers merge custom and bundled options', function () {
+    $connection = fleetopsVehicleModelUseInMemoryConnection();
+    $connection->table('files')->insert([
+        'uuid'              => 'avatar-uuid',
+        'url'               => 'https://cdn.test/custom.png',
+        'type'              => 'vehicle-avatar',
+        'original_filename' => 'reefer.png',
+    ]);
+
+    $options = Vehicle::getAvatarOptions(function ($query) {
+        $query->where('uuid', 'avatar-uuid');
+    });
+
+    expect($options->get('Custom: reefer'))->toBe('avatar-uuid')
+        ->and($options->has('mini_bus'))->toBeTrue()
+        ->and(Vehicle::getAvatar('mini_bus'))->toBe($options->get('mini_bus'))
+        ->and(Vehicle::getAvatar('11111111-1111-4111-8111-111111111111'))->toBeNull()
+        ->and((new Vehicle())->getAvatarUrlAttribute(''))->toBe($options->get('mini_bus'));
+});
+
+test('vehicle driver assignment helpers update assigned state', function () {
+    $connection = fleetopsVehicleModelUseInMemoryConnection();
+    $connection->table('users')->insert(['uuid' => 'user-uuid']);
+    $connection->table('drivers')->insert(['user_uuid' => 'user-uuid', 'vehicle_uuid' => 'vehicle-uuid']);
+
+    $vehicle = new Vehicle();
+    $vehicle->setRawAttributes(['uuid' => 'vehicle-uuid'], true);
+
+    $driver = new FleetOpsVehicleModelAssignableDriverFake();
+
+    expect($vehicle->assignDriver($driver))->toBe($vehicle)
+        ->and($driver->assignedVehicle)->toBe($vehicle);
+
+    $vehicle->setRelation('driver', $driver);
+
+    expect($vehicle->unassignDriver())->toBe($vehicle)
+        ->and($vehicle->relationLoaded('driver'))->toBeFalse()
+        ->and($connection->table('drivers')->where('vehicle_uuid', 'vehicle-uuid')->count())->toBe(0)
+        ->and($connection->table('drivers')->whereNull('vehicle_uuid')->count())->toBe(1);
+});
+
+test('vehicle import parses single vehicle name and find by name builds identifier query', function () {
+    $vehicle = Vehicle::createFromImport([
+        'vehicle_name' => '2018 Ford Transit refrigerated van',
+    ]);
+
+    expect($vehicle->exists)->toBeFalse()
+        ->and($vehicle->company_uuid)->toBe('company-vehicle')
+        ->and($vehicle->make)->toBe('Ford')
+        ->and($vehicle->model)->toBe('TRANSIT')
+        ->and($vehicle->year)->toBe('2018')
+        ->and($vehicle->type)->toBe('vehicle')
+        ->and(Vehicle::findByName())->toBeNull();
+
+    $found                                    = new Vehicle();
+    FleetOpsVehicleModelFindableFake::$result = $found;
+
+    expect(FleetOpsVehicleModelFindableFake::findByName('ABC-123'))->toBe($found)
+        ->and(FleetOpsVehicleModelFindableFake::$lastQuery->calls)->toContain(['where', ['public_id', 'ABC-123']])
+        ->and(FleetOpsVehicleModelFindableFake::$lastQuery->calls)->toContain(['orWhere', ['plate_number', 'ABC-123']])
+        ->and(FleetOpsVehicleModelFindableFake::$lastQuery->calls)->toContain(['orWhere', ['fuel_card_number', 'ABC-123']])
+        ->and(FleetOpsVehicleModelFindableFake::$lastQuery->calls[7][0])->toBe('orWhereRaw')
+        ->and(FleetOpsVehicleModelFindableFake::$lastQuery->calls[8][0])->toBe('orWhereRaw');
+});