@fleetbase/fleetops-engine 0.6.57 → 0.6.59

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

@@ -0,0 +1,319 @@
+<?php
+
+use Fleetbase\FleetOps\Models\Equipment;
+use Fleetbase\FleetOps\Models\MaintenanceSchedule;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Models\Vendor;
+use Fleetbase\FleetOps\Models\WorkOrder;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+use Illuminate\Database\Eloquent\Relations\MorphTo;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Support\Carbon;
+
+class FleetOpsMaintenanceScheduleImportProbe extends MaintenanceSchedule
+{
+    public static ?Vehicle $vehicle     = null;
+    public static ?Equipment $equipment = null;
+    public static ?Vendor $vendor       = null;
+    public static array $lookups        = [];
+    public array $saves                 = [];
+
+    public static function resetProbe(): void
+    {
+        static::$vehicle   = null;
+        static::$equipment = null;
+        static::$vendor    = null;
+        static::$lookups   = [];
+    }
+
+    public function save(array $options = []): bool
+    {
+        $this->saves[] = $options;
+
+        return true;
+    }
+
+    protected static function findImportVehicle(string $vehicleName): ?Vehicle
+    {
+        static::$lookups[] = ['vehicle', $vehicleName, session('company')];
+
+        return static::$vehicle;
+    }
+
+    protected static function findImportEquipment(string $vehicleName): ?Equipment
+    {
+        static::$lookups[] = ['equipment', $vehicleName, session('company')];
+
+        return static::$equipment;
+    }
+
+    protected static function findImportVendor(string $vendorName): ?Vendor
+    {
+        static::$lookups[] = ['vendor', $vendorName, session('company')];
+
+        return static::$vendor;
+    }
+}
+
+class FleetOpsMaintenanceScheduleUpdatingFake 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;
+    }
+}
+
+function fleetopsMaintenanceScheduleUseRelationConnection(): void
+{
+    $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
+    $resolver   = new ConnectionResolver([
+        'default' => $connection,
+        'mysql'   => $connection,
+    ]);
+
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+}
+
+function fleetopsMaintenanceScheduleVehicle(string $uuid = 'vehicle-uuid'): Vehicle
+{
+    $vehicle = new Vehicle();
+    $vehicle->setRawAttributes([
+        'uuid'      => $uuid,
+        'public_id' => 'vehicle_public',
+        'name'      => 'Truck 9',
+    ], true);
+    $vehicle->setAppends([]);
+
+    return $vehicle;
+}
+
+function fleetopsMaintenanceScheduleEquipment(string $uuid = 'equipment-uuid'): Equipment
+{
+    $equipment = new Equipment();
+    $equipment->setRawAttributes([
+        'uuid'      => $uuid,
+        'public_id' => 'equipment_public',
+        'name'      => 'Forklift 2',
+    ], true);
+    $equipment->setAppends([]);
+
+    return $equipment;
+}
+
+function fleetopsMaintenanceScheduleVendor(string $uuid = 'vendor-uuid'): Vendor
+{
+    $vendor = new Vendor();
+    $vendor->setRawAttributes([
+        'uuid' => $uuid,
+        'name' => 'Vendor Ops',
+    ], true);
+    $vendor->setAppends([]);
+
+    return $vendor;
+}
+
+test('maintenance schedule relationship contracts resolve expected relation types', function () {
+    fleetopsMaintenanceScheduleUseRelationConnection();
+
+    $schedule = new MaintenanceSchedule();
+
+    expect($schedule->subject())->toBeInstanceOf(MorphTo::class)
+        ->and($schedule->defaultAssignee())->toBeInstanceOf(MorphTo::class)
+        ->and($schedule->workOrders())->toBeInstanceOf(HasMany::class)
+        ->and($schedule->workOrders()->getRelated())->toBeInstanceOf(WorkOrder::class);
+});
+
+test('maintenance schedule due checks cover inactive and threshold branches', function () {
+    $schedule = new MaintenanceSchedule([
+        'status'                => 'active',
+        'next_due_date'         => Carbon::parse('2026-02-01'),
+        'next_due_odometer'     => 15000,
+        'next_due_engine_hours' => 600,
+    ]);
+
+    expect($schedule->isDue(null, null, Carbon::parse('2026-01-15')))->toBeFalse()
+        ->and($schedule->isDue(null, null, Carbon::parse('2026-02-01')))->toBeTrue()
+        ->and($schedule->isDue(15000, null, Carbon::parse('2026-01-15')))->toBeTrue()
+        ->and($schedule->isDue(null, 600, Carbon::parse('2026-01-15')))->toBeTrue();
+
+    $schedule->status = 'paused';
+
+    expect($schedule->isDue(20000, 900, Carbon::parse('2026-03-01')))->toBeFalse();
+});
+
+test('maintenance schedule reset uses existing readings when completion readings are omitted', function () {
+    Carbon::setTestNow(Carbon::parse('2026-03-10 10:00:00'));
+
+    $schedule = new FleetOpsMaintenanceScheduleUpdatingFake([
+        'last_service_odometer'      => 11000,
+        'last_service_engine_hours'  => 450,
+        'interval_value'             => null,
+        'interval_unit'              => null,
+        'interval_distance'          => 5000,
+        'interval_engine_hours'      => 250,
+    ]);
+
+    expect($schedule->resetAfterCompletion())->toBeTrue()
+        ->and($schedule->updates[0]['last_service_date']->toDateTimeString())->toBe('2026-03-10 10:00:00')
+        ->and($schedule->updates[0]['last_service_odometer'])->toBe(11000)
+        ->and($schedule->updates[0]['last_service_engine_hours'])->toBe(450)
+        ->and($schedule->pause())->toBeTrue()
+        ->and($schedule->resume())->toBeTrue()
+        ->and($schedule->complete())->toBeTrue()
+        ->and($schedule->updates[0])->not->toHaveKey('status')
+        ->and($schedule->updates[1]['status'])->toBe('paused')
+        ->and($schedule->updates[2]['status'])->toBe('active')
+        ->and($schedule->updates[3]['status'])->toBe('completed');
+
+    Carbon::setTestNow();
+});
+
+test('maintenance schedule import maps vehicle vendor defaults and saves when requested', function () {
+    session(['company' => 'company-uuid']);
+
+    FleetOpsMaintenanceScheduleImportProbe::resetProbe();
+    FleetOpsMaintenanceScheduleImportProbe::$vehicle = fleetopsMaintenanceScheduleVehicle();
+    FleetOpsMaintenanceScheduleImportProbe::$vendor  = fleetopsMaintenanceScheduleVendor();
+
+    $schedule = FleetOpsMaintenanceScheduleImportProbe::createFromImport([
+        'schedule_name'              => 'Quarterly service',
+        'schedule_type'              => 'inspection',
+        'status'                     => 'paused',
+        'interval_method'            => 'meter',
+        'interval_type'              => 'recurring',
+        'interval_value'             => '90',
+        'interval_unit'              => 'days',
+        'interval_distance'          => '5000',
+        'interval_engine_hours'      => '250',
+        'last_service_odometer'      => '10000',
+        'last_service_engine_hours'  => '400',
+        'last_service_date'          => '2026-01-01',
+        'next_due_date'              => '2026-04-01',
+        'next_due_odometer'          => '15000',
+        'next_due_engine_hours'      => '650',
+        'default_priority'           => 'high',
+        'description'                => 'Inspect brakes',
+        'vehicle_name'               => 'Truck 9',
+        'vendor_name'                => 'Vendor Ops',
+    ], true);
+
+    expect($schedule)->toBeInstanceOf(FleetOpsMaintenanceScheduleImportProbe::class)
+        ->and($schedule->company_uuid)->toBe('company-uuid')
+        ->and($schedule->name)->toBe('Quarterly service')
+        ->and($schedule->type)->toBe('inspection')
+        ->and($schedule->status)->toBe('paused')
+        ->and($schedule->interval_value)->toBe(90)
+        ->and($schedule->interval_distance)->toBe(5000.0)
+        ->and($schedule->interval_engine_hours)->toBe(250.0)
+        ->and($schedule->last_service_date->toDateString())->toBe('2026-01-01')
+        ->and($schedule->next_due_date->toDateString())->toBe('2026-04-01')
+        ->and($schedule->next_due_odometer)->toBe(15000.0)
+        ->and($schedule->next_due_engine_hours)->toBe(650.0)
+        ->and($schedule->default_priority)->toBe('high')
+        ->and($schedule->instructions)->toBe('Inspect brakes')
+        ->and($schedule->subject_type)->toBe(Vehicle::class)
+        ->and($schedule->subject_uuid)->toBe('vehicle-uuid')
+        ->and($schedule->default_assignee_type)->toBe(Vendor::class)
+        ->and($schedule->default_assignee_uuid)->toBe('vendor-uuid')
+        ->and($schedule->saves)->toBe([[]])
+        ->and(FleetOpsMaintenanceScheduleImportProbe::$lookups)->toBe([
+            ['vehicle', 'Truck 9', 'company-uuid'],
+            ['vendor', 'Vendor Ops', 'company-uuid'],
+        ]);
+});
+
+test('maintenance schedule import falls back to equipment and default values', function () {
+    session(['company' => 'company-uuid']);
+
+    FleetOpsMaintenanceScheduleImportProbe::resetProbe();
+    FleetOpsMaintenanceScheduleImportProbe::$equipment = fleetopsMaintenanceScheduleEquipment();
+
+    $schedule = FleetOpsMaintenanceScheduleImportProbe::createFromImport([
+        'name'              => 'Equipment service',
+        'asset'             => 'Forklift 2',
+        'default_assignee'  => 'Missing Vendor',
+    ]);
+
+    expect($schedule->type)->toBe('preventive')
+        ->and($schedule->status)->toBe('active')
+        ->and($schedule->interval_method)->toBe('time')
+        ->and($schedule->interval_type)->toBe('recurring')
+        ->and($schedule->interval_unit)->toBe('days')
+        ->and($schedule->default_priority)->toBe('normal')
+        ->and($schedule->subject_type)->toBe(Equipment::class)
+        ->and($schedule->subject_uuid)->toBe('equipment-uuid')
+        ->and($schedule->default_assignee_type)->toBeNull()
+        ->and($schedule->default_assignee_uuid)->toBeNull()
+        ->and($schedule->saves)->toBe([])
+        ->and(FleetOpsMaintenanceScheduleImportProbe::$lookups)->toBe([
+            ['vehicle', 'Forklift 2', 'company-uuid'],
+            ['equipment', 'Forklift 2', 'company-uuid'],
+            ['vendor', 'Missing Vendor', 'company-uuid'],
+        ]);
+});
+
+test('activity log options and import lookups resolve maintainables', function () {
+    fleetopsMaintenanceScheduleUseRelationConnection();
+    $connection = EloquentModel::resolveConnection('mysql');
+    $connection->getPdo()->sqliteCreateFunction('CONCAT', fn (...$parts) => implode('', array_map(fn ($part) => (string) $part, $parts)));
+    app()->instance('db', new class($connection) {
+        public function __construct(public $c)
+        {
+        }
+
+        public function connection($name = null)
+        {
+            return $this->c;
+        }
+
+        public function __call($method, $arguments)
+        {
+            return $this->c->{$method}(...$arguments);
+        }
+    });
+    Illuminate\Support\Facades\DB::clearResolvedInstance('db');
+    $schema = $connection->getSchemaBuilder();
+    foreach (['vehicles' => ['uuid', 'public_id', 'company_uuid', 'plate_number', 'vin', 'internal_id', 'make', 'model', 'year', 'display_name'], 'equipments' => ['uuid', 'public_id', 'company_uuid', 'name', 'serial_number'], 'vendors' => ['uuid', 'public_id', 'company_uuid', 'name']] as $table => $columns) {
+        $schema->create($table, function ($blueprint) use ($columns) {
+            $blueprint->increments('id');
+            foreach ($columns as $column) {
+                $blueprint->string($column)->nullable();
+            }
+            $blueprint->timestamps();
+            $blueprint->timestamp('deleted_at')->nullable();
+        });
+    }
+    $connection->table('vehicles')->insert(['uuid' => 'veh-imp-1', 'company_uuid' => 'company-1', 'plate_number' => 'SGX1234', 'make' => 'Ford', 'model' => 'Transit', 'year' => '2022']);
+    $connection->table('equipments')->insert(['uuid' => 'eq-imp-1', 'public_id' => 'equipment_impone', 'company_uuid' => 'company-1', 'name' => 'Forklift Alpha', 'serial_number' => 'SN-100']);
+    $connection->table('vendors')->insert(['uuid' => 'ven-imp-1', 'company_uuid' => 'company-1', 'name' => 'Servicing Partners']);
+    session(['company' => 'company-1']);
+
+    $schedule = new MaintenanceSchedule();
+    expect($schedule->getActivitylogOptions())->toBeInstanceOf(Spatie\Activitylog\LogOptions::class);
+
+    $invoke = function (string $name, ...$arguments) {
+        $reflection = new ReflectionMethod(MaintenanceSchedule::class, $name);
+        $reflection->setAccessible(true);
+
+        return $reflection->invoke(null, ...$arguments);
+    };
+
+    expect($invoke('findImportVehicle', 'SGX1234')?->uuid)->toBe('veh-imp-1')
+        ->and($invoke('findImportEquipment', 'Forklift')?->uuid)->toBe('eq-imp-1')
+        ->and($invoke('findImportEquipment', 'SN-100')?->uuid)->toBe('eq-imp-1')
+        ->and($invoke('findImportVendor', 'Servicing')?->uuid)->toBe('ven-imp-1')
+        ->and($invoke('findImportVendor', 'Unknown Vendor'))->toBeNull();
+});

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

@@ -0,0 +1,277 @@
+<?php
+
+if (!function_exists('Fleetbase\FleetOps\Models\session')) {
+    eval('namespace Fleetbase\FleetOps\Models; function session($key = null, $default = null) { return $key === "company" ? "company-maintenance" : $default; }');
+}
+
+if (!function_exists('Fleetbase\FleetOps\Models\activity')) {
+    eval('namespace Fleetbase\FleetOps\Models; function activity($logName = null) { return new class($logName) { public function __construct(public $logName) {} public function performedOn($subject) { return $this; } public function withProperties(array $properties) { return $this; } public function log(string $message) { return true; } }; }');
+}
+
+use Fleetbase\FleetOps\Models\Maintenance;
+use Fleetbase\FleetOps\Models\WorkOrder;
+use Fleetbase\Models\Model as FleetbaseModel;
+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 FleetOpsMaintenanceModelDatabaseProbe
+{
+    public function __construct(private SQLiteConnection $connection)
+    {
+    }
+
+    public function connection(): SQLiteConnection
+    {
+        return $this->connection;
+    }
+
+    public function raw(string $value)
+    {
+        return $this->connection->raw($value);
+    }
+}
+
+class FleetOpsMaintenanceQueryFake
+{
+    public array $calls = [];
+
+    public function where(...$arguments): static
+    {
+        $this->calls[] = ['where', $arguments];
+
+        return $this;
+    }
+}
+
+class FleetOpsMaintenanceUpdatingFake extends Maintenance
+{
+    public array $updates = [];
+
+    public function update(array $attributes = [], array $options = []): bool
+    {
+        $this->updates[] = $attributes;
+        $this->forceFill($attributes);
+
+        return true;
+    }
+}
+
+class FleetOpsMaintenanceMaintainableFake extends FleetbaseModel
+{
+    public array $odometers   = [];
+    public array $engineHours = [];
+
+    public function updateOdometer($odometer, string $source): void
+    {
+        $this->odometers[] = [$odometer, $source];
+    }
+
+    public function updateEngineHours($engineHours, string $source): void
+    {
+        $this->engineHours[] = [$engineHours, $source];
+    }
+}
+
+function fleetopsMaintenanceModelUseInMemoryConnection(): 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 FleetOpsMaintenanceModelDatabaseProbe($connection));
+    app()->instance('db.schema', $connection->getSchemaBuilder());
+
+    return $connection;
+}
+
+beforeEach(function () {
+    fleetopsMaintenanceModelUseInMemoryConnection();
+    Carbon::setTestNow(Carbon::parse('2026-07-27 12:00:00'));
+});
+
+afterEach(function () {
+    Carbon::setTestNow();
+});
+
+test('maintenance relationship contracts and activity options are stable', function () {
+    $maintenance = new Maintenance();
+
+    expect($maintenance->getActivitylogOptions())->toBeInstanceOf(LogOptions::class)
+        ->and($maintenance->workOrder())->toBeInstanceOf(BelongsTo::class)
+        ->and($maintenance->workOrder()->getRelated())->toBeInstanceOf(WorkOrder::class)
+        ->and($maintenance->workOrder()->getForeignKeyName())->toBe('work_order_uuid')
+        ->and($maintenance->createdBy())->toBeInstanceOf(BelongsTo::class)
+        ->and($maintenance->createdBy()->getRelated())->toBeInstanceOf(User::class)
+        ->and($maintenance->updatedBy())->toBeInstanceOf(BelongsTo::class)
+        ->and($maintenance->updatedBy()->getRelated())->toBeInstanceOf(User::class)
+        ->and($maintenance->maintainable())->toBeInstanceOf(MorphTo::class)
+        ->and($maintenance->maintainable()->getMorphType())->toBe('maintainable_type')
+        ->and($maintenance->maintainable()->getForeignKeyName())->toBe('maintainable_uuid')
+        ->and($maintenance->performedBy())->toBeInstanceOf(MorphTo::class)
+        ->and($maintenance->performedBy()->getMorphType())->toBe('performed_by_type')
+        ->and($maintenance->performedBy()->getForeignKeyName())->toBe('performed_by_uuid');
+});
+
+test('maintenance scopes write expected query constraints', function () {
+    $maintenance = new Maintenance();
+    $query       = new FleetOpsMaintenanceQueryFake();
+
+    expect($maintenance->scopeByStatus($query, 'completed'))->toBe($query)
+        ->and($maintenance->scopeScheduled($query))->toBe($query)
+        ->and($maintenance->scopeOverdue($query))->toBe($query)
+        ->and($maintenance->scopeByType($query, 'inspection'))->toBe($query)
+        ->and($maintenance->scopeByPriority($query, 'high'))->toBe($query)
+        ->and($query->calls[0])->toBe(['where', ['status', 'completed']])
+        ->and($query->calls[1])->toBe(['where', ['status', 'scheduled']])
+        ->and($query->calls[2][0])->toBe('where')
+        ->and($query->calls[2][1][0])->toBe('scheduled_at')
+        ->and($query->calls[2][1][1])->toBe('<')
+        ->and($query->calls[3])->toBe(['where', ['status', '!=', 'completed']])
+        ->and($query->calls[4])->toBe(['where', ['type', 'inspection']])
+        ->and($query->calls[5])->toBe(['where', ['priority', 'high']]);
+});
+
+test('maintenance accessors handle empty and related states', function () {
+    $namedMaintainable = new FleetOpsMaintenanceMaintainableFake();
+    $namedMaintainable->setRawAttributes(['name' => 'Lift gate'], true);
+
+    $displayMaintainable = new FleetOpsMaintenanceMaintainableFake();
+    $displayMaintainable->setRawAttributes(['display_name' => 'Trailer unit'], true);
+
+    $performer = new FleetOpsMaintenanceMaintainableFake();
+    $performer->setRawAttributes(['display_name' => 'Contractor Team'], true);
+
+    $maintenance = new Maintenance([
+        'status'       => 'scheduled',
+        'scheduled_at' => Carbon::parse('2026-07-28 12:00:00'),
+        'started_at'   => Carbon::parse('2026-07-27 08:00:00'),
+        'completed_at' => Carbon::parse('2026-07-27 11:00:00'),
+        'labor_cost'   => 2000,
+        'parts_cost'   => 1500,
+        'tax'          => 250,
+        'total_cost'   => 3750,
+        'meta'         => ['estimated_duration_hours' => 2],
+    ]);
+    $maintenance->setRelation('maintainable', $namedMaintainable);
+    $maintenance->setRelation('performedBy', $performer);
+    $maintenance->setRelation('workOrder', (object) ['subject' => 'Hydraulic inspection']);
+
+    $displayMaintenance = new Maintenance();
+    $displayMaintenance->setRelation('maintainable', $displayMaintainable);
+
+    $empty = new Maintenance();
+
+    expect($maintenance->maintainable_name)->toBe('Lift gate')
+        ->and($displayMaintenance->maintainable_name)->toBe('Trailer unit')
+        ->and($empty->maintainable_name)->toBeNull()
+        ->and($maintenance->performed_by_name)->toBe('Contractor Team')
+        ->and($empty->performed_by_name)->toBeNull()
+        ->and($maintenance->work_order_subject)->toBe('Hydraulic inspection')
+        ->and($empty->work_order_subject)->toBeNull()
+        ->and($maintenance->duration_hours)->toBe(3.0)
+        ->and($empty->duration_hours)->toBeNull()
+        ->and($maintenance->is_overdue)->toBeFalse()
+        ->and($maintenance->days_until_due)->toBe(1)
+        ->and($maintenance->cost_breakdown)->toMatchArray([
+            'subtotal'   => 3500,
+            'total_cost' => 3750,
+        ])
+        ->and($maintenance->getEfficiencyRating())->toBe(66.66666666666666)
+        ->and($maintenance->wasCompletedOnTime())->toBeTrue()
+        ->and($maintenance->getCostPerHour())->toBe(1250.0)
+        ->and($empty->getEfficiencyRating())->toBeNull()
+        ->and($empty->wasCompletedOnTime())->toBeNull()
+        ->and($empty->getCostPerHour())->toBeNull();
+});
+
+test('maintenance lifecycle success branches update state and maintainable readings', function () {
+    $performer = new FleetOpsMaintenanceMaintainableFake();
+    $performer->setRawAttributes(['uuid' => 'user-performer'], true);
+
+    $maintenance = new FleetOpsMaintenanceUpdatingFake([
+        'status'     => 'scheduled',
+        'labor_cost' => 1000,
+        'parts_cost' => 2000,
+        'tax'        => 100,
+    ]);
+
+    expect($maintenance->start($performer))->toBeTrue()
+        ->and($maintenance->updates[0]['status'])->toBe('in_progress')
+        ->and($maintenance->updates[0]['started_at']->toDateTimeString())->toBe('2026-07-27 12:00:00')
+        ->and($maintenance->updates[0]['performed_by_type'])->toBe(FleetOpsMaintenanceMaintainableFake::class)
+        ->and($maintenance->updates[0]['performed_by_uuid'])->toBe('user-performer');
+
+    $maintainable = new FleetOpsMaintenanceMaintainableFake();
+    $maintenance->setRelation('maintainable', $maintainable);
+
+    expect($maintenance->complete([
+        'labor_cost'   => 1200,
+        'parts_cost'   => 2500,
+        'tax'          => 300,
+        'notes'        => 'Completed with calibration',
+        'line_items'   => [['name' => 'Filter']],
+        'attachments'  => [['file_uuid' => 'file-uuid']],
+        'odometer'     => 12345,
+        'engine_hours' => 88,
+    ]))->toBeTrue()
+        ->and($maintenance->updates[1]['status'])->toBe('completed')
+        ->and($maintenance->updates[1]['completed_at']->toDateTimeString())->toBe('2026-07-27 12:00:00')
+        ->and($maintenance->updates[1]['total_cost'])->toBe(4000)
+        ->and($maintenance->updates[1]['notes'])->toBe('Completed with calibration')
+        ->and($maintainable->odometers)->toBe([[12345, 'maintenance']])
+        ->and($maintainable->engineHours)->toBe([[88, 'maintenance']]);
+});
+
+test('maintenance cancellation line items attachments and mutators are stable', function () {
+    $maintenance = new FleetOpsMaintenanceUpdatingFake([
+        'status'      => 'scheduled',
+        'line_items'  => [['name' => 'Existing']],
+        'attachments' => [],
+        'meta'        => ['source' => 'import'],
+    ]);
+
+    expect($maintenance->cancel('Duplicate request'))->toBeTrue()
+        ->and($maintenance->updates[0])->toMatchArray([
+            'status' => 'canceled',
+            'meta'   => [
+                'source'              => 'import',
+                'cancellation_reason' => 'Duplicate request',
+            ],
+        ])
+        ->and($maintenance->addLineItem(['name' => 'Filter', 'unit_cost' => 1200]))->toBeTrue()
+        ->and($maintenance->updates[1]['line_items'][1]['name'])->toBe('Filter')
+        ->and($maintenance->updates[1]['line_items'][1]['added_at']->toDateTimeString())->toBe('2026-07-27 12:00:00')
+        ->and($maintenance->removeLineItem(0))->toBeTrue()
+        ->and($maintenance->updates[2]['line_items'])->toHaveCount(1)
+        ->and($maintenance->removeLineItem(10))->toBeFalse()
+        ->and($maintenance->addAttachment('file-uuid', 'Invoice'))->toBeTrue()
+        ->and($maintenance->updates[3]['attachments'][0])->toMatchArray([
+            'file_uuid'   => 'file-uuid',
+            'description' => 'Invoice',
+        ]);
+
+    $invalidLineItems = new Maintenance();
+    $invalidLineItems->setLineItemsAttribute('not-json');
+
+    $normalisedLineItems = new Maintenance();
+    $normalisedLineItems->setLineItemsAttribute([
+        ['name' => 'Labor', 'unit_cost' => '100.25'],
+        ['name' => 'Inspection'],
+    ]);
+
+    expect($invalidLineItems->getAttributes()['line_items'])->toBe('[]')
+        ->and(json_decode($normalisedLineItems->getAttributes()['line_items'], true))->toBe([
+            ['name' => 'Labor', 'unit_cost' => 10025],
+            ['name' => 'Inspection'],
+        ]);
+});