@fleetbase/fleetops-engine 0.6.57 → 0.6.59

package/server/tests/InternalImportExportControllerContractsTest.php

@@ -0,0 +1,289 @@
+<?php
+
+use Fleetbase\FleetOps\Exports\EquipmentExport;
+use Fleetbase\FleetOps\Exports\FuelReportExport;
+use Fleetbase\FleetOps\Exports\PartExport;
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\EquipmentController;
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\FuelReportController;
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\PartController;
+use Fleetbase\FleetOps\Imports\EquipmentImport;
+use Fleetbase\FleetOps\Imports\FuelReportImport;
+use Fleetbase\FleetOps\Imports\PartImport;
+use Fleetbase\FleetOps\Models\FuelReport;
+use Fleetbase\Http\Requests\ExportRequest;
+use Fleetbase\Http\Requests\ImportRequest;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+if (!class_exists('Fleetbase\Http\Requests\ExportRequest', false)) {
+    eval('namespace Fleetbase\Http\Requests; class ExportRequest extends \Illuminate\Http\Request {}');
+}
+
+if (!class_exists('Fleetbase\Http\Requests\ImportRequest', false)) {
+    eval('namespace Fleetbase\Http\Requests; class ImportRequest extends \Illuminate\Http\Request {}');
+}
+
+class FleetOpsInternalExportRequestFake extends ExportRequest
+{
+    public function array($key = null, $default = [])
+    {
+        $value = $this->input($key, $default);
+
+        return is_array($value) ? $value : $default;
+    }
+}
+
+class FleetOpsInternalImportRequestFake extends ImportRequest
+{
+    public array $resolvedFiles = [];
+
+    public function array($key = null, $default = [])
+    {
+        $value = $this->input($key, $default);
+
+        return is_array($value) ? $value : $default;
+    }
+
+    public function resolveFilesFromIds(string $param = 'files')
+    {
+        return collect($this->resolvedFiles);
+    }
+}
+
+class FleetOpsInternalEquipmentImportFake extends EquipmentImport
+{
+    public function __construct(int $imported)
+    {
+        $this->imported = $imported;
+    }
+}
+
+class FleetOpsInternalFuelReportImportFake extends FuelReportImport
+{
+    public function __construct(int $imported)
+    {
+        $this->imported = $imported;
+    }
+}
+
+class FleetOpsInternalPartImportFake extends PartImport
+{
+    public function __construct(int $imported)
+    {
+        $this->imported = $imported;
+    }
+}
+
+class FleetOpsInternalEquipmentControllerProbe extends EquipmentController
+{
+    public array $downloads = [];
+    public array $imports   = [];
+    public array $imported  = [2, 3];
+    public bool $failImport = false;
+
+    protected function downloadExport(EquipmentExport $export, string $fileName)
+    {
+        $this->downloads[] = [$export, $fileName];
+
+        return ['download' => $fileName, 'headings' => $export->headings()];
+    }
+
+    protected function createImport(): EquipmentImport
+    {
+        return new FleetOpsInternalEquipmentImportFake(array_shift($this->imported) ?? 0);
+    }
+
+    protected function importFile(EquipmentImport $import, string $path, string $disk): void
+    {
+        if ($this->failImport) {
+            throw new RuntimeException('invalid equipment import');
+        }
+
+        $this->imports[] = [$import->imported, $path, $disk];
+    }
+}
+
+class FleetOpsInternalFuelReportControllerProbe extends FuelReportController
+{
+    public array $downloads        = [];
+    public array $imports          = [];
+    public array $syncedFieldSets  = [];
+    public array $imported         = [4, 5];
+    public bool $failImport        = false;
+
+    protected function downloadExport(FuelReportExport $export, string $fileName)
+    {
+        $this->downloads[] = [$export, $fileName];
+
+        return ['download' => $fileName, 'headings' => $export->headings()];
+    }
+
+    protected function createImport(): FuelReportImport
+    {
+        return new FleetOpsInternalFuelReportImportFake(array_shift($this->imported) ?? 0);
+    }
+
+    protected function importFile(FuelReportImport $import, string $path, string $disk): void
+    {
+        if ($this->failImport) {
+            throw new RuntimeException('invalid fuel report import');
+        }
+
+        $this->imports[] = [$import->imported, $path, $disk];
+    }
+}
+
+class FleetOpsInternalPartControllerProbe extends PartController
+{
+    public array $downloads = [];
+    public array $imports   = [];
+    public array $imported  = [6, 7];
+    public bool $failImport = false;
+
+    protected function downloadExport(PartExport $export, string $fileName)
+    {
+        $this->downloads[] = [$export, $fileName];
+
+        return ['download' => $fileName, 'headings' => $export->headings()];
+    }
+
+    protected function createImport(): PartImport
+    {
+        return new FleetOpsInternalPartImportFake(array_shift($this->imported) ?? 0);
+    }
+
+    protected function importFile(PartImport $import, string $path, string $disk): void
+    {
+        if ($this->failImport) {
+            throw new RuntimeException('invalid part import');
+        }
+
+        $this->imports[] = [$import->imported, $path, $disk];
+    }
+}
+
+class FleetOpsInternalFuelReportAfterSaveFake extends FuelReport
+{
+    public array $synced = [];
+
+    public function syncCustomFieldValues(array $payload, array $options = []): array
+    {
+        $this->synced[] = [$payload, $options];
+
+        return $payload;
+    }
+}
+
+function fleetopsInternalExportRequest(array $input): FleetOpsInternalExportRequestFake
+{
+    return FleetOpsInternalExportRequestFake::create('/internal/export', 'POST', $input);
+}
+
+function fleetopsInternalImportRequest(array $files, array $input = []): FleetOpsInternalImportRequestFake
+{
+    $request                = FleetOpsInternalImportRequestFake::create('/internal/import', 'POST', $input);
+    $request->resolvedFiles = array_map(fn (string $path) => (object) ['path' => $path], $files);
+
+    return $request;
+}
+
+function fleetopsJsonPayload(JsonResponse $response): array
+{
+    return json_decode($response->getContent(), true);
+}
+
+function fleetopsExportSelections(object $export): array
+{
+    $property = new ReflectionProperty($export, 'selections');
+    $property->setAccessible(true);
+
+    return $property->getValue($export);
+}
+
+test('internal equipment fuel report and part controllers download selected exports', function () {
+    $equipment = new FleetOpsInternalEquipmentControllerProbe();
+    $fuel      = new FleetOpsInternalFuelReportControllerProbe();
+    $part      = new FleetOpsInternalPartControllerProbe();
+
+    $equipmentResponse = $equipment->export(fleetopsInternalExportRequest([
+        'format'     => 'csv',
+        'selections' => ['equipment-a', 'equipment-b'],
+    ]));
+    $fuelResponse = $fuel->export(fleetopsInternalExportRequest([
+        'format'     => 'xlsx',
+        'selections' => ['fuel-a'],
+    ]));
+    $partResponse = $part->export(fleetopsInternalExportRequest([
+        'format'     => 'xls',
+        'selections' => ['part-a', 'part-b'],
+    ]));
+
+    expect($equipmentResponse['download'])->toMatch('/^equipment-[0-9-]+\\.csv$/')
+        ->and(fleetopsExportSelections($equipment->downloads[0][0]))->toBe(['equipment-a', 'equipment-b'])
+        ->and($equipmentResponse['headings'])->toContain('Serial Number')
+        ->and($fuelResponse['download'])->toMatch('/^fuel-report-[0-9-]+\\.xlsx$/')
+        ->and(fleetopsExportSelections($fuel->downloads[0][0]))->toBe(['fuel-a'])
+        ->and($fuelResponse['headings'])->toContain('Odometer')
+        ->and($partResponse['download'])->toMatch('/^parts-[0-9-]+\\.xls$/')
+        ->and(fleetopsExportSelections($part->downloads[0][0]))->toBe(['part-a', 'part-b'])
+        ->and($partResponse['headings'])->toContain('Part Number');
+});
+
+test('internal equipment fuel report and part controllers import files and report totals', function () {
+    $equipment = new FleetOpsInternalEquipmentControllerProbe();
+    $fuel      = new FleetOpsInternalFuelReportControllerProbe();
+    $part      = new FleetOpsInternalPartControllerProbe();
+
+    $equipmentResponse = $equipment->import(fleetopsInternalImportRequest(['equipment-a.csv', 'equipment-b.csv'], ['disk' => 'imports']));
+    $fuelResponse      = $fuel->import(fleetopsInternalImportRequest(['fuel-a.csv', 'fuel-b.csv'], ['disk' => 's3']));
+    $partResponse      = $part->import(fleetopsInternalImportRequest(['part-a.csv', 'part-b.csv'], ['disk' => 'local']));
+
+    expect(fleetopsJsonPayload($equipmentResponse))->toBe(['status' => 'ok', 'message' => 'Import completed', 'imported' => 5])
+        ->and($equipment->imports)->toBe([[2, 'equipment-a.csv', 'imports'], [3, 'equipment-b.csv', 'imports']])
+        ->and(fleetopsJsonPayload($fuelResponse))->toBe(['status' => 'ok', 'message' => 'Import completed', 'imported' => 9])
+        ->and($fuel->imports)->toBe([[4, 'fuel-a.csv', 's3'], [5, 'fuel-b.csv', 's3']])
+        ->and(fleetopsJsonPayload($partResponse))->toBe(['status' => 'ok', 'message' => 'Import completed', 'imported' => 13])
+        ->and($part->imports)->toBe([[6, 'part-a.csv', 'local'], [7, 'part-b.csv', 'local']]);
+});
+
+test('internal import controllers return controller specific invalid file errors', function () {
+    $equipment             = new FleetOpsInternalEquipmentControllerProbe();
+    $equipment->failImport = true;
+    $fuel                  = new FleetOpsInternalFuelReportControllerProbe();
+    $fuel->failImport      = true;
+    $part                  = new FleetOpsInternalPartControllerProbe();
+    $part->failImport      = true;
+
+    expect(fleetopsJsonPayload($equipment->import(fleetopsInternalImportRequest(['bad-equipment.csv']))))->toBe([
+        'error' => 'Invalid file, unable to process.',
+    ])
+        ->and(fleetopsJsonPayload($fuel->import(fleetopsInternalImportRequest(['bad-fuel.csv']))))->toBe([
+            'error' => 'Invalid file, unable to proccess.',
+        ])
+        ->and(fleetopsJsonPayload($part->import(fleetopsInternalImportRequest(['bad-part.csv']))))->toBe([
+            'error' => 'Invalid file, unable to process.',
+        ]);
+});
+
+test('internal fuel report controller syncs custom fields after save when provided', function () {
+    $controller = new FleetOpsInternalFuelReportControllerProbe();
+    $fuelReport = new FleetOpsInternalFuelReportAfterSaveFake();
+
+    $controller->afterSave(new Request([
+        'fuel_report' => [
+            'custom_field_values' => [
+                ['key' => 'receipt_number', 'value' => 'R-100'],
+            ],
+        ],
+    ]), $fuelReport);
+    $controller->afterSave(new Request(['fuel_report' => ['custom_field_values' => []]]), $fuelReport);
+
+    expect($fuelReport->synced)->toBe([
+        [
+            [
+                ['key' => 'receipt_number', 'value' => 'R-100'],
+            ],
+            [],
+        ],
+    ]);
+});

package/server/tests/InternalMetricsControllerContractsTest.php

@@ -0,0 +1,69 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\MetricsController;
+use Illuminate\Http\Request;
+use Illuminate\Support\Carbon;
+use Illuminate\Support\Stringable;
+
+class FleetOpsMetricsRequestFake extends Request
+{
+    public function __construct(private array $values = [])
+    {
+        parent::__construct();
+    }
+
+    public function string($key = null, $default = null): Stringable
+    {
+        return str((string) ($this->values[$key] ?? $default ?? ''));
+    }
+
+    public function date($key = null, $format = null, $tz = null): ?Carbon
+    {
+        if (!array_key_exists($key, $this->values) || $this->values[$key] === null) {
+            return null;
+        }
+
+        return Carbon::parse($this->values[$key], $tz);
+    }
+}
+
+function fleetopsMetricsResolvePeriod(array $input): array
+{
+    $controller = new MetricsController();
+    $method     = new ReflectionMethod(MetricsController::class, 'resolvePeriod');
+    $method->setAccessible(true);
+
+    return $method->invoke($controller, new FleetOpsMetricsRequestFake($input));
+}
+
+test('internal metrics controller resolves supported shorthand periods', function () {
+    Carbon::setTestNow(Carbon::parse('2026-07-26 12:00:00'));
+
+    try {
+        [$start, $end] = fleetopsMetricsResolvePeriod(['period' => '14d']);
+
+        expect($start->format('Y-m-d H:i:s'))->toBe('2026-07-12 12:00:00')
+            ->and($end->format('Y-m-d H:i:s'))->toBe('2026-07-26 12:00:00');
+    } finally {
+        Carbon::setTestNow();
+    }
+});
+
+test('internal metrics controller resolves explicit and default date windows', function () {
+    Carbon::setTestNow(Carbon::parse('2026-07-26 12:00:00'));
+
+    try {
+        [$explicitStart, $explicitEnd] = fleetopsMetricsResolvePeriod([
+            'start' => '2026-06-01 00:00:00',
+            'end'   => '2026-06-30 23:59:59',
+        ]);
+        [$defaultStart, $defaultEnd] = fleetopsMetricsResolvePeriod(['period' => 'unsupported']);
+
+        expect($explicitStart->format('Y-m-d H:i:s'))->toBe('2026-06-01 00:00:00')
+            ->and($explicitEnd->format('Y-m-d H:i:s'))->toBe('2026-06-30 23:59:59')
+            ->and($defaultStart->format('Y-m-d H:i:s'))->toBe('2026-06-26 12:00:00')
+            ->and($defaultEnd->format('Y-m-d H:i:s'))->toBe('2026-07-26 12:00:00');
+    } finally {
+        Carbon::setTestNow();
+    }
+});

package/server/tests/InternalPlaceWorkOrderControllerContractsTest.php

@@ -0,0 +1,207 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\PlaceController;
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\WorkOrderController;
+use Fleetbase\FleetOps\Models\Place;
+use Fleetbase\FleetOps\Models\WorkOrder;
+use Illuminate\Http\Request;
+use Illuminate\Support\Collection;
+
+if (!function_exists('Fleetbase\Traits\config')) {
+    eval('namespace Fleetbase\Traits; function config($key = null, $default = null) { return false; }');
+}
+
+if (!function_exists('Fleetbase\Models\config')) {
+    eval('namespace Fleetbase\Models; function config($key = null, $default = null) { return $default; }');
+}
+
+if (!Request::hasMacro('searchQuery')) {
+    Request::macro('searchQuery', fn () => $this->input('query', $this->input('search', $this->input('searchQuery'))));
+}
+
+class FleetOpsInternalPlaceControllerProbe extends PlaceController
+{
+    public array $synced   = [];
+    public array $searches = [];
+    public array $avatars  = [
+        ['name' => 'Warehouse', 'icon' => 'warehouse'],
+    ];
+    public Collection $searchResults;
+    public FleetOpsPlaceQueryFake $query;
+
+    public function __construct()
+    {
+        $this->searchResults = collect();
+        $this->query         = new FleetOpsPlaceQueryFake();
+    }
+
+    protected function syncCustomFieldValues(Place $place, array $customFieldValues): void
+    {
+        $this->synced[] = [$place->public_id, $customFieldValues];
+    }
+
+    protected function newPlaceQuery()
+    {
+        return $this->query;
+    }
+
+    protected function searchPlaces($query, ?string $searchQuery, array $options)
+    {
+        $this->searches[] = [$query, $searchQuery, $options];
+
+        return $this->searchResults;
+    }
+
+    protected function avatarOptions(): array
+    {
+        return $this->avatars;
+    }
+}
+
+class FleetOpsPlaceQueryFake
+{
+    public array $calls = [];
+
+    public function where(...$arguments): self
+    {
+        $this->calls[] = ['where', $arguments];
+
+        return $this;
+    }
+
+    public function whereNull(string $column): self
+    {
+        $this->calls[] = ['whereNull', $column];
+
+        return $this;
+    }
+
+    public function applyDirectivesForPermissions(string $permission): self
+    {
+        $this->calls[] = ['applyDirectivesForPermissions', $permission];
+
+        return $this;
+    }
+}
+
+class FleetOpsInternalWorkOrderControllerProbe extends WorkOrderController
+{
+    public ?WorkOrder $workOrder = null;
+    public array $lookups        = [];
+    public array $mail           = [];
+    public array $activity       = [];
+
+    protected function workOrderForEmail(string $id): WorkOrder
+    {
+        $this->lookups[] = $id;
+
+        return $this->workOrder;
+    }
+
+    protected function sendWorkOrderDispatchedMail(string $email, WorkOrder $workOrder): void
+    {
+        $this->mail[] = [$email, $workOrder->public_id];
+    }
+
+    protected function recordWorkOrderSentActivity(WorkOrder $workOrder, string $email): void
+    {
+        $this->activity[] = [$workOrder->public_id, $email];
+    }
+}
+
+function fleetopsInternalPlace(array $attributes): Place
+{
+    $place = new Place();
+    $place->setRawAttributes($attributes, true);
+
+    return $place;
+}
+
+function fleetopsInternalWorkOrder(?object $assignee): WorkOrder
+{
+    $workOrder = new WorkOrder();
+    $workOrder->setRawAttributes(['public_id' => 'wo_public'], true);
+    $workOrder->setRelation('assignee', $assignee);
+
+    return $workOrder;
+}
+
+test('internal place controller syncs custom fields and returns avatars', function () {
+    $controller = new FleetOpsInternalPlaceControllerProbe();
+    $place      = fleetopsInternalPlace(['public_id' => 'place_public']);
+
+    $controller->afterSave(new Request([
+        'place' => [
+            'custom_field_values' => [
+                ['key' => 'dock', 'value' => 'A1'],
+            ],
+        ],
+    ]), $place);
+
+    expect($controller->synced)->toBe([
+        ['place_public', [['key' => 'dock', 'value' => 'A1']]],
+    ]);
+
+    $controller->afterSave(new Request(['place' => ['custom_field_values' => []]]), $place);
+
+    expect($controller->synced)->toHaveCount(1)
+        ->and($controller->avatars()->getData(true))->toBe($controller->avatars);
+});
+
+test('internal place controller delegates search options', function () {
+    session(['company' => 'company-uuid']);
+
+    $controller                = new FleetOpsInternalPlaceControllerProbe();
+    $controller->searchResults = collect([fleetopsInternalPlace(['public_id' => 'place_public', 'name' => 'Central Depot'])]);
+
+    $searchResponse = $controller->search(new Request([
+        'query'     => 'depot',
+        'limit'     => 10,
+        'geo'       => true,
+        'latitude'  => '1.3000',
+        'longitude' => '103.8000',
+    ]));
+
+    expect($searchResponse->collection)->toHaveCount(1)
+        ->and($controller->query->calls)->toContain(['where', ['company_uuid', 'company-uuid']])
+        ->and($controller->query->calls)->toContain(['whereNull', 'deleted_at'])
+        ->and($controller->query->calls)->toContain(['applyDirectivesForPermissions', 'fleet-ops list place'])
+        ->and($controller->searches[0][1])->toBe('depot')
+        ->and($controller->searches[0][2])->toMatchArray([
+            'limit'     => 10,
+            'geo'       => true,
+            'latitude'  => '1.3000',
+            'longitude' => '103.8000',
+        ]);
+});
+
+test('internal work order controller handles missing assignee email and successful sends', function () {
+    $controller            = new FleetOpsInternalWorkOrderControllerProbe();
+    $controller->workOrder = fleetopsInternalWorkOrder(null);
+    $missingAssignee       = $controller->sendEmail('wo_public');
+
+    expect($missingAssignee->getStatusCode())->toBe(422)
+        ->and($missingAssignee->getData(true))->toBe([
+            'error' => 'This work order has no assigned vendor.',
+        ]);
+
+    $controller->workOrder = fleetopsInternalWorkOrder((object) ['email' => null]);
+
+    $missingEmail = $controller->sendEmail('wo_public');
+
+    expect($missingEmail->getStatusCode())->toBe(422)
+        ->and($missingEmail->getData(true))->toBe([
+            'error' => 'The assigned vendor has no email address on file.',
+        ]);
+
+    $controller->workOrder = fleetopsInternalWorkOrder((object) ['email' => 'vendor@example.test']);
+    $sent                  = $controller->sendEmail('wo_public');
+
+    expect($sent->getData(true))->toBe([
+        'status'  => 'ok',
+        'message' => 'Work order successfully sent to vendor@example.test',
+    ])
+        ->and($controller->lookups)->toBe(['wo_public', 'wo_public', 'wo_public'])
+        ->and($controller->mail)->toBe([['vendor@example.test', 'wo_public']])
+        ->and($controller->activity)->toBe([['wo_public', 'vendor@example.test']]);
+});