@fleetbase/fleetops-engine 0.6.57 → 0.6.59

package/server/tests/LookupAndGeocoderControllerContractsTest.php

@@ -0,0 +1,357 @@
+<?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 (!class_exists('Fleetbase\Http\Requests\Internal\BulkDeleteRequest', false)) {
+    eval('namespace Fleetbase\Http\Requests\Internal; class BulkDeleteRequest extends \Illuminate\Http\Request {}');
+}
+
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\FleetOpsLookupController;
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\GeocoderController;
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\IntegratedVendorController;
+use Fleetbase\FleetOps\Models\Contact;
+use Fleetbase\FleetOps\Models\IntegratedVendor;
+use Fleetbase\FleetOps\Models\Vendor;
+use Illuminate\Http\Request;
+use Illuminate\Support\Collection;
+
+if (!method_exists(Request::class, 'or')) {
+    Request::macro('or', function (array $keys, mixed $default = null) {
+        foreach ($keys as $key) {
+            if ($this->has($key)) {
+                return $this->input($key);
+            }
+        }
+
+        return $default;
+    });
+}
+
+class FleetOpsGeocoderControllerProbe extends GeocoderController
+{
+    public Collection $forwardResults;
+    public Collection $reverseResults;
+    public array $forwardCalls  = [];
+    public array $reverseCalls  = [];
+    public array $createdPlaces = [];
+
+    public function __construct()
+    {
+        $this->forwardResults = collect();
+        $this->reverseResults = collect();
+    }
+
+    protected function reverseGeocode(float $latitude, float $longitude)
+    {
+        $this->reverseCalls[] = [$latitude, $longitude];
+
+        return $this->reverseResults;
+    }
+
+    protected function forwardGeocode(string $query)
+    {
+        $this->forwardCalls[] = $query;
+
+        return $this->forwardResults;
+    }
+
+    protected function placeFromGoogleAddress($googleAddress)
+    {
+        $place = [
+            'address' => $googleAddress->address,
+            'source'  => $googleAddress->source,
+        ];
+        $this->createdPlaces[] = $place;
+
+        return $place;
+    }
+}
+
+class FleetOpsLookupControllerProbe extends FleetOpsLookupController
+{
+    public Collection $contacts;
+    public Collection $vendors;
+    public Collection $integrated;
+    public array $calls = [];
+
+    public function __construct()
+    {
+        $this->contacts   = collect();
+        $this->vendors    = collect();
+        $this->integrated = collect();
+    }
+
+    protected function searchContacts(?string $query, int|string $limit)
+    {
+        $this->calls[] = ['contacts', $query, $limit];
+
+        return $this->contacts;
+    }
+
+    protected function searchVendors(?string $query, int|string $limit)
+    {
+        $this->calls[] = ['vendors', $query, $limit];
+
+        return $this->vendors;
+    }
+
+    protected function integratedVendors()
+    {
+        $this->calls[] = ['integrated'];
+
+        return $this->integrated;
+    }
+}
+
+class FleetOpsIntegratedVendorControllerProbe extends IntegratedVendorController
+{
+    public Collection $supported;
+    public FleetOpsIntegratedVendorQueryFake $query;
+    public array $queryIds      = [];
+    public array $errors        = [];
+    public array $jsonResponses = [];
+
+    public function __construct()
+    {
+        $this->supported = collect();
+        $this->query     = new FleetOpsIntegratedVendorQueryFake();
+    }
+
+    protected function supportedIntegratedVendors()
+    {
+        return $this->supported;
+    }
+
+    protected function integratedVendorQuery(array $ids)
+    {
+        $this->queryIds[] = $ids;
+
+        return $this->query;
+    }
+
+    protected function jsonResponse(array $payload, int $status = 200)
+    {
+        $this->jsonResponses[] = [$payload, $status];
+
+        return ['json' => $payload, 'status' => $status];
+    }
+
+    protected function errorResponse(string $message)
+    {
+        $this->errors[] = $message;
+
+        return ['error' => $message];
+    }
+}
+
+class FleetOpsIntegratedVendorQueryFake
+{
+    public int $count   = 0;
+    public int $deleted = 0;
+
+    public function count(): int
+    {
+        return $this->count;
+    }
+
+    public function delete(): int
+    {
+        return $this->deleted;
+    }
+}
+
+function fleetopsLookupContact(string $name): Contact
+{
+    $contact = new class extends Contact {
+        public function toArray(): array
+        {
+            return $this->getAttributes();
+        }
+    };
+    $contact->setRawAttributes(['uuid' => strtolower(str_replace(' ', '-', $name)), 'name' => $name], true);
+
+    return $contact;
+}
+
+function fleetopsLookupVendor(string $name): Vendor
+{
+    $vendor = new class extends Vendor {
+        public function toArray(): array
+        {
+            return $this->getAttributes();
+        }
+    };
+    $vendor->setRawAttributes(['uuid' => strtolower(str_replace(' ', '-', $name)), 'name' => $name], true);
+
+    return $vendor;
+}
+
+function fleetopsLookupIntegratedVendor(string $name): IntegratedVendor
+{
+    $vendor = new class extends IntegratedVendor {
+        public function toArray(): array
+        {
+            return $this->getAttributes();
+        }
+    };
+    $vendor->setRawAttributes(['uuid' => strtolower(str_replace(' ', '-', $name)), 'name' => $name], true);
+
+    return $vendor;
+}
+
+test('geocoder controller handles invalid empty single and multiple reverse geocode responses', function () {
+    $controller = new FleetOpsGeocoderControllerProbe();
+
+    $invalid = $controller->reverse(new Request(['coordinates' => 'not-coordinates']));
+    $empty   = $controller->reverse(new Request(['coordinates' => [1.3, 103.8]]));
+
+    $controller->reverseResults = collect([
+        (object) ['address' => 'One Way', 'source' => 'reverse-a'],
+        (object) ['address' => 'Two Way', 'source' => 'reverse-b'],
+    ]);
+
+    $single = $controller->reverse(new Request(['coordinates' => [1.3, 103.8], 'single' => true]));
+    $many   = $controller->reverse(new Request(['coordinates' => [1.3, 103.8]]));
+
+    // Unusable coordinates are rejected outright. They must not fall through to
+    // a Point(0, 0) and reverse-geocode Null Island, so no lookup is attempted
+    expect($invalid->getData(true))->toBe(['error' => 'Invalid coordinates provided.'])
+        ->and($empty->getData(true))->toBe([])
+        ->and($single->getData(true))->toBe(['address' => 'One Way', 'source' => 'reverse-a'])
+        ->and($many->getData(true))->toBe([
+            ['address' => 'One Way', 'source' => 'reverse-a'],
+            ['address' => 'Two Way', 'source' => 'reverse-b'],
+        ])
+        ->and($controller->reverseCalls)->toBe([
+            [1.3, 103.8],
+            [1.3, 103.8],
+            [1.3, 103.8],
+        ]);
+});
+
+test('geocoder controller handles forward geocode array delegation and result shapes', function () {
+    $controller                 = new FleetOpsGeocoderControllerProbe();
+    $controller->forwardResults = collect([
+        (object) ['address' => 'Forward One', 'source' => 'forward-a'],
+        (object) ['address' => 'Forward Two', 'source' => 'forward-b'],
+    ]);
+    $controller->reverseResults = collect([
+        (object) ['address' => 'Reverse One', 'source' => 'reverse-a'],
+    ]);
+
+    $single    = $controller->geocode(new Request(['query' => 'depot', 'single' => true]));
+    $many      = $controller->geocode(new Request(['query' => 'depot']));
+    $delegated = $controller->geocode(new Request(['query' => [1.3, 103.8], 'single' => true]));
+
+    $emptyController = new FleetOpsGeocoderControllerProbe();
+    $empty           = $emptyController->geocode(new Request(['query' => 'missing']));
+
+    expect($single->getData(true))->toBe(['address' => 'Forward One', 'source' => 'forward-a'])
+        ->and($many->getData(true))->toBe([
+            ['address' => 'Forward One', 'source' => 'forward-a'],
+            ['address' => 'Forward Two', 'source' => 'forward-b'],
+        ])
+        ->and($delegated->getData(true))->toBe(['address' => 'Reverse One', 'source' => 'reverse-a'])
+        ->and($empty->getData(true))->toBe([])
+        ->and($controller->forwardCalls)->toBe(['depot', 'depot']);
+});
+
+test('fleet ops lookup controller merges polymorphic contacts vendors and integrated facilitators', function () {
+    session(['company' => 'company-uuid']);
+
+    $controller             = new FleetOpsLookupControllerProbe();
+    $controller->contacts   = collect([fleetopsLookupContact('Beta Contact')]);
+    $controller->vendors    = collect([fleetopsLookupVendor('Alpha Vendor')]);
+    $controller->integrated = collect([fleetopsLookupIntegratedVendor('Zulu Integrated')]);
+
+    $response = $controller->polymorphs(Request::create('/int/v1/fleet-ops/facilitators', 'GET', [
+        'q'     => 'vendor',
+        'limit' => 7,
+    ]));
+
+    $data = $response->getData(true);
+
+    expect($data['facilitators'])->toHaveCount(3)
+        ->and($data['facilitators'][0])->toBe([
+            'uuid'             => 'zulu-integrated',
+            'name'             => 'Zulu Integrated',
+            'facilitator_type' => 'integrated-vendor',
+            'type'             => 'facilitator',
+        ])
+        ->and($data['facilitators'][1])->toMatchArray([
+            'uuid' => 'alpha-vendor',
+            'name' => 'Alpha Vendor',
+            'type' => 'facilitator',
+        ])
+        ->and($data['facilitators'][2])->toMatchArray([
+            'uuid' => 'beta-contact',
+            'name' => 'Beta Contact',
+            'type' => 'facilitator',
+        ])
+        ->and($data['facilitators'][1]['facilitator_type'])->toContain('lookupandgeocodercontrollercontractstest')
+        ->and($data['facilitators'][2]['facilitator_type'])->toContain('lookupandgeocodercontrollercontractstest')
+        ->and($controller->calls)->toBe([
+            ['contacts', 'vendor', 7],
+            ['vendors', 'vendor', 7],
+            ['integrated'],
+        ]);
+});
+
+test('integrated vendor controller returns supported vendors', function () {
+    $controller            = new FleetOpsIntegratedVendorControllerProbe();
+    $controller->supported = collect([
+        new class {
+            public function toArray(): array
+            {
+                return ['key' => 'lalamove', 'name' => 'Lalamove'];
+            }
+        },
+    ]);
+
+    $supported = $controller->getSupported(new Request());
+
+    expect($supported->getData(true))->toBe([['key' => 'lalamove', 'name' => 'Lalamove']])
+        ->and($controller->queryIds)->toBe([]);
+});
+
+test('integrated vendor controller bulk deletes selected vendors', function () {
+    $controller                 = new FleetOpsIntegratedVendorControllerProbe();
+    $controller->query->count   = 2;
+    $controller->query->deleted = 2;
+
+    $response = $controller->bulkDelete(new Fleetbase\Http\Requests\Internal\BulkDeleteRequest([
+        'ids' => ['vendor-a', 'vendor-b'],
+    ]));
+
+    expect($response)->toBe([
+        'json' => [
+            'status'  => 'OK',
+            'message' => 'Deleted 2 integrated vendors',
+        ],
+        'status' => 200,
+    ])->and($controller->queryIds)->toBe([['vendor-a', 'vendor-b']])
+        ->and($controller->errors)->toBe([]);
+});
+
+test('integrated vendor controller reports empty or failed bulk deletes', function () {
+    $empty = new FleetOpsIntegratedVendorControllerProbe();
+
+    expect($empty->bulkDelete(new Fleetbase\Http\Requests\Internal\BulkDeleteRequest()))->toBe([
+        'error' => 'Nothing to delete.',
+    ])->and($empty->queryIds)->toBe([]);
+
+    $failed               = new FleetOpsIntegratedVendorControllerProbe();
+    $failed->query->count = 2;
+
+    expect($failed->bulkDelete(new Fleetbase\Http\Requests\Internal\BulkDeleteRequest([
+        'ids' => ['vendor-a', 'vendor-b'],
+    ])))->toBe([
+        'error' => 'Failed to bulk delete vendors.',
+    ])->and($failed->queryIds)->toBe([['vendor-a', 'vendor-b']]);
+});

package/server/tests/MaintainableTraitContractsTest.php

@@ -0,0 +1,245 @@
+<?php
+
+use Carbon\Carbon;
+use Fleetbase\FleetOps\Traits\Maintainable;
+use Illuminate\Support\Collection;
+
+class FleetOpsMaintainableRelationProbe
+{
+    public array $calls = [];
+
+    public function __construct(private Collection $records, private mixed $firstRecord = null, private bool $exists = false)
+    {
+    }
+
+    public function where(...$arguments): self
+    {
+        $this->calls[] = ['where', $arguments];
+
+        return $this;
+    }
+
+    public function whereNotNull(...$arguments): self
+    {
+        $this->calls[] = ['whereNotNull', $arguments];
+
+        return $this;
+    }
+
+    public function orderBy(...$arguments): self
+    {
+        $this->calls[] = ['orderBy', $arguments];
+
+        return $this;
+    }
+
+    public function get(): Collection
+    {
+        return $this->records;
+    }
+
+    public function first(): mixed
+    {
+        return $this->firstRecord;
+    }
+
+    public function exists(): bool
+    {
+        return $this->exists;
+    }
+
+    public function count(): int
+    {
+        return $this->records->count();
+    }
+
+    public function sum(string $key): mixed
+    {
+        return $this->records->sum($key);
+    }
+}
+
+class FleetOpsMaintainableProbe
+{
+    use Maintainable {
+        checkIntervalsSinceDate as public exposeCheckIntervalsSinceDate;
+        checkMaintenanceIntervals as public exposeCheckMaintenanceIntervals;
+    }
+
+    public ?object $last_maintenance = null;
+    public array $specs              = [];
+    public array $meta               = [];
+    public ?Carbon $created_at       = null;
+    public ?Carbon $purchased_at     = null;
+    public ?int $odometer            = null;
+    public ?int $engine_hours        = null;
+
+    public FleetOpsMaintainableRelationProbe $overdueRelation;
+    public FleetOpsMaintainableRelationProbe $completedRelation;
+    public FleetOpsMaintainableRelationProbe $scheduledRelation;
+    public FleetOpsMaintainableRelationProbe $maintenanceRelation;
+
+    public function __construct()
+    {
+        $this->created_at          = now()->subDays(20);
+        $this->overdueRelation     = new FleetOpsMaintainableRelationProbe(collect());
+        $this->completedRelation   = new FleetOpsMaintainableRelationProbe(collect());
+        $this->scheduledRelation   = new FleetOpsMaintainableRelationProbe(collect());
+        $this->maintenanceRelation = new FleetOpsMaintainableRelationProbe(collect());
+    }
+
+    public function overdueMaintenances(): FleetOpsMaintainableRelationProbe
+    {
+        return $this->overdueRelation;
+    }
+
+    public function completedMaintenances(): FleetOpsMaintainableRelationProbe
+    {
+        return $this->completedRelation;
+    }
+
+    public function scheduledMaintenances(): FleetOpsMaintainableRelationProbe
+    {
+        return $this->scheduledRelation;
+    }
+
+    public function maintenances(): FleetOpsMaintainableRelationProbe
+    {
+        return $this->maintenanceRelation;
+    }
+}
+
+class FleetOpsCompletedMaintenanceProbe
+{
+    public string $status = 'completed';
+    public Carbon $started_at;
+    public Carbon $completed_at;
+
+    public function __construct(
+        public float $total_cost,
+        public int $duration_hours,
+        public string $type,
+        private bool $onTime,
+    ) {
+        $this->started_at   = Carbon::parse('2026-07-01 08:00:00');
+        $this->completed_at = $this->started_at->copy()->addHours($duration_hours);
+    }
+
+    public function wasCompletedOnTime(): bool
+    {
+        return $this->onTime;
+    }
+}
+
+test('maintainable interval checks use date odometer and engine hour thresholds', function () {
+    $probe        = new FleetOpsMaintainableProbe();
+    $probe->specs = [
+        'maintenance_interval_days'  => 10,
+        'maintenance_interval_miles' => 500,
+        'maintenance_interval_hours' => 25,
+    ];
+    $probe->last_maintenance = (object) [
+        'completed_at' => now()->subDays(3),
+        'odometer'     => 1200,
+        'engine_hours' => 40,
+    ];
+    $probe->odometer     = 1800;
+    $probe->engine_hours = 70;
+
+    expect($probe->exposeCheckIntervalsSinceDate(now()->subDays(11)))->toBeTrue()
+        ->and($probe->exposeCheckIntervalsSinceDate(now()->subDays(1)))->toBeTrue()
+        ->and($probe->exposeCheckMaintenanceIntervals())->toBeTrue();
+
+    $probe->specs            = ['maintenance_interval_days' => 30];
+    $probe->last_maintenance = null;
+    $probe->purchased_at     = now()->subDays(31);
+
+    expect($probe->exposeCheckMaintenanceIntervals())->toBeTrue();
+
+    $probe->specs            = [];
+    $probe->meta             = ['maintenance_interval_days' => 7];
+    $probe->created_at       = now()->subDays(8);
+    $probe->purchased_at     = null;
+    $probe->last_maintenance = null;
+
+    expect($probe->exposeCheckMaintenanceIntervals())->toBeTrue();
+});
+
+test('maintainable status helpers report overdue and aggregate maintenance metrics', function () {
+    $probe                  = new FleetOpsMaintainableProbe();
+    $probe->overdueRelation = new FleetOpsMaintainableRelationProbe(collect(), null, true);
+
+    expect($probe->needsMaintenance())->toBeTrue();
+
+    $completed = collect([
+        new FleetOpsCompletedMaintenanceProbe(120.0, 2, 'inspection', true),
+        new FleetOpsCompletedMaintenanceProbe(80.0, 3, 'repair', false),
+    ]);
+    $probe->completedRelation = new FleetOpsMaintainableRelationProbe($completed, $completed->first());
+
+    expect($probe->getMaintenanceCost(30))->toBe(200.0)
+        ->and($probe->getMaintenanceFrequency(30))->toBe((2 / 30) * 365)
+        ->and($probe->getAverageMaintenanceDuration(30))->toBe(2.5)
+        ->and($probe->getMaintenanceEfficiency(30))->toBe(50.0);
+});
+
+test('maintainable schedules and history summaries project maintenance state', function () {
+    $probe        = new FleetOpsMaintainableProbe();
+    $probe->specs = [
+        'maintenance_intervals' => [
+            'inspection' => [
+                'days'        => 30,
+                'priority'    => 'high',
+                'description' => 'Inspect brakes',
+            ],
+        ],
+    ];
+    $lastCompleted            = (object) ['completed_at' => now()->subDays(10)];
+    $probe->completedRelation = new FleetOpsMaintainableRelationProbe(collect([
+        new FleetOpsCompletedMaintenanceProbe(100, 2, 'inspection', true),
+        new FleetOpsCompletedMaintenanceProbe(50, 1, 'inspection', false),
+    ]), $lastCompleted);
+    $probe->scheduledRelation = new FleetOpsMaintainableRelationProbe(collect([
+        (object) [
+            'status'       => 'scheduled',
+            'scheduled_at' => now()->addDays(5),
+        ],
+    ]));
+    $probe->maintenanceRelation = new FleetOpsMaintainableRelationProbe(collect([
+        new FleetOpsCompletedMaintenanceProbe(100, 2, 'inspection', true),
+        (object) [
+            'status'       => 'scheduled',
+            'scheduled_at' => now()->subDay(),
+        ],
+    ]));
+
+    $schedule = $probe->createPreventiveMaintenanceSchedule([
+        'oil_change' => ['days' => 45],
+    ]);
+
+    expect($probe->getUpcomingMaintenance(14))->toHaveCount(1)
+        ->and($schedule)->toHaveCount(2)
+        ->and($schedule[0])->toMatchArray([
+            'type'          => 'inspection',
+            'interval_days' => 30,
+            'priority'      => 'high',
+            'description'   => 'Inspect brakes',
+        ])
+        ->and($schedule[1])->toMatchArray([
+            'type'          => 'oil_change',
+            'interval_days' => 45,
+            'priority'      => 'medium',
+            'description'   => 'Scheduled oil_change maintenance',
+        ])
+        ->and($probe->getMaintenanceHistorySummary(60))->toMatchArray([
+            'total_maintenances'     => 2,
+            'completed_count'        => 1,
+            'scheduled_count'        => 1,
+            'overdue_count'          => 1,
+            'total_cost'             => 100,
+            'average_cost'           => 100,
+            'total_downtime_hours'   => 2,
+            'average_duration_hours' => 2,
+            'most_common_type'       => 'inspection',
+        ]);
+});