@fleetbase/fleetops-engine 0.6.57 → 0.6.59

package/server/tests/Feature/Http/Internal/CustomerControllerCredentialsTest.php

@@ -0,0 +1,196 @@
+<?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 (!function_exists('Fleetbase\Support\auth')) {
+    eval('namespace Fleetbase\Support; function auth() { return new class { public function user() { return null; } public function id() { return null; } }; }');
+}
+
+if (!function_exists('Fleetbase\Observers\event')) {
+    eval('namespace Fleetbase\Observers; function event($event = null, $payload = []) { return []; }');
+}
+
+if (!function_exists('Fleetbase\\FleetOps\\Http\\Controllers\\Internal\\v1\\abort_if')) {
+    eval('namespace Fleetbase\\FleetOps\\Http\\Controllers\\Internal\\v1; function abort_if($condition, $code = 400, $message = \'\') { if ($condition) { throw new \\RuntimeException($message !== \'\' ? $message : (string) $code); } }');
+}
+
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\CustomerController;
+use Fleetbase\FleetOps\Models\Contact;
+use Fleetbase\Models\User;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Http\Request;
+
+/**
+ * Covers the internal CustomerController resetCredentials endpoint against
+ * SQLite: missing-customer and mismatched-password rejections, successful
+ * password changes with optional credential mail dispatch, and the customer,
+ * user, password and payload helper seams.
+ */
+class FleetOpsInternalCustomerProbe extends CustomerController
+{
+    public function callHelper(string $method, ...$arguments): mixed
+    {
+        return $this->{$method}(...$arguments);
+    }
+}
+
+function fleetopsCustomerCredentialsBoot(): SQLiteConnection
+{
+    $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
+    $resolver   = new ConnectionResolver(['default' => $connection, 'mysql' => $connection]);
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+    if (!EloquentModel::getEventDispatcher()) {
+        EloquentModel::setEventDispatcher(new Illuminate\Events\Dispatcher());
+    }
+    app()->instance('db', new class($connection) {
+        public function __construct(public SQLiteConnection $c)
+        {
+        }
+
+        public function connection($name = null): SQLiteConnection
+        {
+            return $this->c;
+        }
+
+        public function __call($method, $arguments)
+        {
+            return $this->c->{$method}(...$arguments);
+        }
+    });
+    app()->instance('db.schema', $connection->getSchemaBuilder());
+    Illuminate\Support\Facades\DB::clearResolvedInstance('db');
+
+    app()->instance('responsecache', new class {
+        public function __call($method, $arguments)
+        {
+            return null;
+        }
+    });
+    app()->instance('hash', new class {
+        public function make($value, array $options = [])
+        {
+            return 'hashed:' . $value;
+        }
+
+        public function check($value, $hashedValue, array $options = [])
+        {
+            return 'hashed:' . $value === $hashedValue;
+        }
+
+        public function needsRehash($hashedValue, array $options = [])
+        {
+            return false;
+        }
+
+        public function __call($method, $arguments)
+        {
+            return null;
+        }
+    });
+    Illuminate\Support\Facades\Hash::clearResolvedInstance('hash');
+
+    Illuminate\Support\Facades\Mail::swap(new class {
+        public array $sent = [];
+
+        public function to($users)
+        {
+            return $this;
+        }
+
+        public function send($mailable)
+        {
+            $this->sent[] = $mailable;
+
+            return null;
+        }
+
+        public function __call($method, $arguments)
+        {
+            return $this;
+        }
+    });
+    $GLOBALS['fleetopsCustomerMailFake'] = Illuminate\Support\Facades\Mail::getFacadeRoot();
+
+    config()->set('activitylog.enabled', false);
+    config()->set('activitylog.default_auth_driver', 'web');
+    app()->bind(Illuminate\Contracts\Config\Repository::class, fn () => config());
+
+    $schema = $connection->getSchemaBuilder();
+    $tables = [
+        'contacts'  => ['uuid', 'public_id', 'company_uuid', 'user_uuid', 'name', 'email', 'phone', 'type', 'title', 'meta', 'photo_uuid', 'place_uuid', 'slug', '_key'],
+        'users'     => ['uuid', 'public_id', 'company_uuid', 'name', 'email', 'phone', 'password', 'type', 'status', 'timezone', 'slug', 'username', 'avatar_uuid', 'meta', '_key'],
+        'companies' => ['uuid', 'public_id', 'name', 'country'],
+        'files'     => ['uuid', 'public_id', 'company_uuid', 'subject_uuid', 'subject_type', 'name', 'path', 'disk', 'type', '_key'],
+    ];
+    foreach ($tables as $table => $columns) {
+        $schema->create($table, function ($blueprint) use ($columns) {
+            $blueprint->increments('id');
+            foreach ($columns as $column) {
+                $blueprint->string($column)->nullable();
+            }
+            $blueprint->timestamps();
+            $blueprint->timestamp('deleted_at')->nullable();
+        });
+    }
+
+    session(['company' => 'company-1']);
+    $connection->table('users')->insert(['uuid' => 'user-1', 'public_id' => 'user_custcred1', 'company_uuid' => 'company-1', 'name' => 'Customer User', 'email' => 'cust@example.com', 'type' => 'customer', 'status' => 'active']);
+    $connection->table('contacts')->insert(['uuid' => '55555555-5555-4555-8555-555555555555', 'public_id' => 'contact_custcred1', 'company_uuid' => 'company-1', 'user_uuid' => 'user-1', 'name' => 'Customer One', 'email' => 'cust@example.com', 'type' => 'customer']);
+
+    return $connection;
+}
+
+test('reset credentials rejects missing customers and mismatched passwords', function () {
+    fleetopsCustomerCredentialsBoot();
+    $controller = new CustomerController();
+
+    $missing = $controller->resetCredentials(Request::create('/x', 'POST', ['password' => 'a', 'password_confirmation' => 'a']));
+    expect($missing->getData(true)['error'])->toContain('No customer specified');
+
+    $mismatch = $controller->resetCredentials(Request::create('/x', 'POST', ['customer' => 'contact_custcred1', 'password' => 'a', 'password_confirmation' => 'b']));
+    expect($mismatch->getData(true)['error'])->toContain('Passwords do not match');
+});
+
+test('reset credentials changes the password and optionally mails credentials', function () {
+    $connection = fleetopsCustomerCredentialsBoot();
+    $controller = new CustomerController();
+
+    $reset = $controller->resetCredentials(Request::create('/x', 'POST', [
+        'customer'              => 'contact_custcred1',
+        'password'              => 'newsecret',
+        'password_confirmation' => 'newsecret',
+    ]));
+    expect($reset->getData(true)['status'] ?? '')->toBe('ok')
+        ->and($connection->table('users')->value('password'))->toContain('newsecret');
+
+    $mailed = $controller->resetCredentials(Request::create('/x', 'POST', [
+        'customer'              => '55555555-5555-4555-8555-555555555555',
+        'password'              => 'mailedsecret',
+        'password_confirmation' => 'mailedsecret',
+        'send_credentials'      => 1,
+    ]));
+    expect($mailed->getData(true)['status'] ?? '')->toBe('ok')
+        ->and($GLOBALS['fleetopsCustomerMailFake']->sent)->not->toBeEmpty();
+});
+
+test('customer resolution and payload helpers expose user details', function () {
+    fleetopsCustomerCredentialsBoot();
+    $probe = new FleetOpsInternalCustomerProbe();
+
+    expect($probe->callHelper('resolveCustomer', Request::create('/x', 'POST', ['customer' => 'contact_custcred1']))->uuid)->toBe('55555555-5555-4555-8555-555555555555')
+        ->and($probe->callHelper('findUser', 'user-1')?->public_id)->toBe('user_custcred1')
+        ->and(strlen($probe->callHelper('randomPassword')))->toBe(16);
+
+    $customer = Contact::where('uuid', '55555555-5555-4555-8555-555555555555')->first();
+    expect($probe->callHelper('resolveCustomerUser', $customer)?->uuid)->toBe('user-1')
+        ->and($probe->callHelper('freshCustomer', $customer)->uuid)->toBe('55555555-5555-4555-8555-555555555555');
+
+    $payload = $probe->callHelper('customerPayload', $customer);
+    expect($payload['uuid'])->toBe('55555555-5555-4555-8555-555555555555')
+        ->and($payload)->toHaveKey('user');
+});

package/server/tests/Feature/Http/Internal/DeviceControllerContractsTest.php

@@ -0,0 +1,370 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\DeviceController;
+use Fleetbase\FleetOps\Models\Device;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\Models\Model;
+use Illuminate\Http\Request;
+
+class FleetOpsInternalDeviceControllerProbe extends DeviceController
+{
+    public ?FleetOpsInternalDeviceFake $device = null;
+    public ?Vehicle $vehicle                   = null;
+    public array $deviceLookups                = [];
+    public array $vehicleLookups               = [];
+    public static array $vehicleUuidLookups    = [];
+    public static array $vehicleUuids          = ['vehicle-uuid'];
+
+    protected function resolveDevice(string $id): ?Device
+    {
+        $this->deviceLookups[] = $id;
+
+        return $this->device;
+    }
+
+    protected function resolveVehicle(?string $id): ?Vehicle
+    {
+        $this->vehicleLookups[] = $id;
+
+        return $this->vehicle;
+    }
+
+    protected static function vehicleUuidsForPublicId(string $vehicle)
+    {
+        static::$vehicleUuidLookups[] = [$vehicle, session('company')];
+
+        return collect(static::$vehicleUuids);
+    }
+}
+
+class FleetOpsInternalDeviceFake extends Device
+{
+    public array $attachedTo = [];
+    public array $detaches   = [];
+    public array $loads      = [];
+    public bool $throwAttach = false;
+    public bool $throwDetach = false;
+
+    public function attachTo(Model $attachable): bool
+    {
+        if ($this->throwAttach) {
+            throw new RuntimeException('attach failed');
+        }
+
+        $this->attachedTo[] = [$attachable::class, $attachable->uuid];
+        $this->forceFill([
+            'attachable_type' => $attachable::class,
+            'attachable_uuid' => $attachable->uuid,
+        ]);
+
+        return true;
+    }
+
+    public function detach(): bool
+    {
+        if ($this->throwDetach) {
+            throw new RuntimeException('detach failed');
+        }
+
+        $this->detaches[] = $this->uuid;
+        $this->forceFill([
+            'attachable_type' => null,
+            'attachable_uuid' => null,
+        ]);
+
+        return true;
+    }
+
+    public function load($relations)
+    {
+        $this->loads[] = $relations;
+
+        return $this;
+    }
+}
+
+class FleetOpsInternalDeviceQueryRecorder
+{
+    public array $calls = [];
+
+    public function with($relations)
+    {
+        $this->calls[] = ['with', $relations];
+
+        return $this;
+    }
+
+    public function withCount($relation)
+    {
+        $this->calls[] = ['withCount', $relation];
+
+        return $this;
+    }
+
+    public function where($column, $operator = null, $value = null, $boolean = 'and')
+    {
+        $this->calls[] = ['where', $column, $operator, $value, $boolean];
+
+        if (is_callable($column)) {
+            $column($this);
+        }
+
+        return $this;
+    }
+
+    public function whereNotNull(string $column)
+    {
+        $this->calls[] = ['whereNotNull', $column];
+
+        return $this;
+    }
+
+    public function whereNull(string $column)
+    {
+        $this->calls[] = ['whereNull', $column];
+
+        return $this;
+    }
+
+    public function orWhere(string $column, $operator = null, $value = null)
+    {
+        $this->calls[] = ['orWhere', $column, $operator, $value];
+
+        return $this;
+    }
+
+    public function orWhereIn(string $column, $values)
+    {
+        $this->calls[] = ['orWhereIn', $column, $values instanceof Illuminate\Support\Collection ? $values->all() : $values];
+
+        return $this;
+    }
+
+    public function orWhereBetween(string $column, array $values)
+    {
+        $this->calls[] = ['orWhereBetween', $column, $values];
+
+        return $this;
+    }
+
+    public function orWhereNull(string $column)
+    {
+        $this->calls[] = ['orWhereNull', $column];
+
+        return $this;
+    }
+
+    public function whereBetween(string $column, array $values)
+    {
+        $this->calls[] = ['whereBetween', $column, $values];
+
+        return $this;
+    }
+
+    public function whereDate(string $column, $value)
+    {
+        $this->calls[] = ['whereDate', $column, $value];
+
+        return $this;
+    }
+}
+
+function fleetopsInternalDeviceController(?FleetOpsInternalDeviceFake $device = null, ?Vehicle $vehicle = null): FleetOpsInternalDeviceControllerProbe
+{
+    FleetOpsInternalDeviceControllerProbe::$vehicleUuidLookups = [];
+    FleetOpsInternalDeviceControllerProbe::$vehicleUuids       = ['vehicle-uuid'];
+
+    $controller          = new FleetOpsInternalDeviceControllerProbe();
+    $controller->device  = $device;
+    $controller->vehicle = $vehicle;
+
+    return $controller;
+}
+
+function fleetopsInternalDevice(): FleetOpsInternalDeviceFake
+{
+    $device = new FleetOpsInternalDeviceFake();
+    $device->setRawAttributes([
+        'uuid'             => 'device-uuid',
+        'public_id'        => 'device_public',
+        'company_uuid'     => 'company-uuid',
+        'attachable_type'  => null,
+        'attachable_uuid'  => null,
+    ], true);
+    $device->setAppends([]);
+
+    return $device;
+}
+
+function fleetopsInternalDeviceVehicle(): Vehicle
+{
+    $vehicle = new Vehicle();
+    $vehicle->setRawAttributes([
+        'uuid'         => 'vehicle-uuid',
+        'public_id'    => 'vehicle_public',
+        'company_uuid' => 'company-uuid',
+    ], true);
+
+    return $vehicle;
+}
+
+function fleetopsInternalDeviceJson(mixed $response): array
+{
+    return $response->getData(true);
+}
+
+test('internal device filter contract remains aligned with model, filter, and controller', function () {
+    $filter     = file_get_contents(dirname(__DIR__, 4) . '/src/Http/Filter/DeviceFilter.php');
+    $model      = file_get_contents(dirname(__DIR__, 4) . '/src/Models/Device.php');
+    $controller = file_get_contents(dirname(__DIR__, 4) . '/src/Http/Controllers/Internal/v1/DeviceController.php');
+
+    expect($model)
+        ->toContain("'vehicle'")
+        ->toContain("'connection_status'")
+        ->toContain("'device_id'")
+        ->toContain("'type'")
+        ->toContain("'serial_number'")
+        ->toContain("'last_online_at'")
+        ->toContain("'updated_at'");
+
+    expect($filter)
+        ->toContain('public function query(?string $searchQuery)')
+        ->toContain('public function deviceId(?string $deviceId)')
+        ->toContain("where('device_id', 'like'")
+        ->toContain('public function type(string|array|null $type)')
+        ->toContain("whereIn('type', \$type)")
+        ->toContain('public function serialNumber(?string $serialNumber)')
+        ->toContain("where('serial_number', 'like'")
+        ->toContain('public function vehicle(?string $vehicle)')
+        ->toContain("wherePublicRelation('attachable_uuid', Vehicle::class, \$vehicle)")
+        ->toContain('public function connectionStatus')
+        ->toContain("'online'")
+        ->toContain("'recently_offline'")
+        ->toContain("'offline'")
+        ->toContain("'long_offline'")
+        ->toContain("'never_connected'")
+        ->toContain('public function lastOnlineAt')
+        ->toContain('public function updatedAt')
+        ->toContain('Utils::dateRange')
+        ->toContain('protected function filterDate');
+
+    expect($controller)
+        ->toContain("withCount('sensors')")
+        ->toContain("filled('connection_status')")
+        ->toContain("filled('serial_number')")
+        ->toContain("filled('last_online_at')")
+        ->toContain("filled('updated_at')");
+});
+
+test('internal device query callback applies relationship, attachment, identifier, status, date, and vehicle filters', function () {
+    session(['company' => 'company-uuid']);
+
+    $query = new FleetOpsInternalDeviceQueryRecorder();
+
+    FleetOpsInternalDeviceControllerProbe::onQueryRecord($query, new Request([
+        'attachment_state'  => 'attached',
+        'vehicle'           => 'vehicle_public',
+        'device_id'         => 'device-123',
+        'serial_number'     => 'serial-456',
+        'connection_status' => ['online', 'recently_offline', 'offline', 'long_offline', 'never_connected', 'ignored'],
+        'last_online_at'    => ['2026-01-01', '2026-01-31'],
+        'updated_at'        => '2026-02-01',
+    ]));
+
+    expect($query->calls)
+        ->toContain(['with', ['telematic', 'warranty', 'attachable']])
+        ->toContain(['withCount', 'sensors'])
+        ->toContain(['whereNotNull', 'attachable_uuid'])
+        ->toContain(['where', 'device_id', 'like', '%device-123%', 'and'])
+        ->toContain(['where', 'serial_number', 'like', '%serial-456%', 'and'])
+        ->toContain(['orWhereIn', 'attachable_uuid', ['vehicle-uuid']])
+        ->and(FleetOpsInternalDeviceControllerProbe::$vehicleUuidLookups)->toBe([['vehicle_public', 'company-uuid']]);
+
+    expect(collect($query->calls)->where(0, 'orWhere')->values()->all())->toHaveCount(2)
+        ->and(collect($query->calls)->where(0, 'orWhereBetween')->values()->all())->toHaveCount(2)
+        ->and(collect($query->calls)->where(0, 'orWhereNull')->values()->all())->toBe([['orWhereNull', 'last_online_at']])
+        ->and(collect($query->calls)->where(0, 'whereBetween')->values()->all())->toHaveCount(1)
+        ->and(collect($query->calls)->where(0, 'whereDate')->values()->all())->toHaveCount(1);
+
+    $unattachedQuery = new FleetOpsInternalDeviceQueryRecorder();
+    FleetOpsInternalDeviceControllerProbe::onQueryRecord($unattachedQuery, new Request([
+        'attachment_state' => 'unattached',
+    ]));
+
+    expect($unattachedQuery->calls)->toContain(['whereNull', 'attachable_uuid']);
+});
+
+test('internal device find callback loads attachment context', function () {
+    $query = new FleetOpsInternalDeviceQueryRecorder();
+
+    FleetOpsInternalDeviceControllerProbe::onFindRecord($query, new Request());
+
+    expect($query->calls)
+        ->toContain(['with', ['telematic', 'warranty', 'attachable']])
+        ->toContain(['withCount', 'sensors']);
+});
+
+test('internal device controller attaches and detaches devices through resolved resources', function () {
+    $device     = fleetopsInternalDevice();
+    $vehicle    = fleetopsInternalDeviceVehicle();
+    $controller = fleetopsInternalDeviceController($device, $vehicle);
+
+    $attached = fleetopsInternalDeviceJson($controller->attach(new Request(['vehicle' => 'vehicle_public']), 'device_public'));
+    $detached = fleetopsInternalDeviceJson($controller->detach('device_public'));
+
+    expect($attached['status'])->toBe('ok');
+    expect($attached['device']['uuid'])->toBe('device-uuid');
+    expect($attached['device']['public_id'])->toBe('device_public');
+    expect($attached['device']['attachable_uuid'])->toBe('vehicle-uuid');
+
+    expect($detached['status'])->toBe('ok');
+    expect($detached['device']['uuid'])->toBe('device-uuid');
+    expect($detached['device']['public_id'])->toBe('device_public');
+    expect($detached['device']['attachable_uuid'])->toBeNull();
+
+    expect($controller->deviceLookups)->toBe(['device_public', 'device_public']);
+    expect($controller->vehicleLookups)->toBe(['vehicle_public']);
+    expect($device->attachedTo)->toBe([[Vehicle::class, 'vehicle-uuid']]);
+    expect($device->detaches)->toBe(['device-uuid']);
+    expect($device->loads)->toBe([
+        ['telematic', 'warranty', 'attachable'],
+        ['telematic', 'warranty', 'attachable'],
+    ]);
+});
+
+test('internal device controller reports lookup and persistence failures', function () {
+    $missingDevice = fleetopsInternalDeviceJson(
+        fleetopsInternalDeviceController(null, fleetopsInternalDeviceVehicle())
+            ->attach(new Request(['vehicle' => 'vehicle_public']), 'missing_device')
+    );
+
+    $missingVehicle = fleetopsInternalDeviceJson(
+        fleetopsInternalDeviceController(fleetopsInternalDevice(), null)
+            ->attach(new Request(['attachable_uuid' => 'missing_vehicle']), 'device_public')
+    );
+
+    $attachFailureDevice              = fleetopsInternalDevice();
+    $attachFailureDevice->throwAttach = true;
+    $attachFailure                    = fleetopsInternalDeviceJson(
+        fleetopsInternalDeviceController($attachFailureDevice, fleetopsInternalDeviceVehicle())
+            ->attach(new Request(['vehicle' => 'vehicle_public']), 'device_public')
+    );
+
+    $detachFailureDevice              = fleetopsInternalDevice();
+    $detachFailureDevice->throwDetach = true;
+    $detachFailure                    = fleetopsInternalDeviceJson(
+        fleetopsInternalDeviceController($detachFailureDevice)
+            ->detach('device_public')
+    );
+
+    $missingDetachDevice = fleetopsInternalDeviceJson(
+        fleetopsInternalDeviceController(null)
+            ->detach('missing_device')
+    );
+
+    expect($missingDevice['error'])->toBe('Device not found or not available for this organization.')
+        ->and($missingVehicle['error'])->toBe('Vehicle not found or not available for this organization.')
+        ->and($attachFailure['error'])->toBe('Unable to attach device to vehicle. Please try again or contact support.')
+        ->and($detachFailure['error'])->toBe('Unable to detach device from vehicle. Please try again or contact support.')
+        ->and($missingDetachDevice['error'])->toBe('Device not found or not available for this organization.');
+});