@fleetbase/fleetops-engine 0.6.58 → 0.6.60

package/server/tests/Unit/Support/TelematicServiceTest.php

@@ -0,0 +1,256 @@
+<?php
+
+use Fleetbase\FleetOps\Models\Device;
+use Fleetbase\FleetOps\Models\Sensor;
+use Fleetbase\FleetOps\Models\Telematic;
+use Fleetbase\FleetOps\Support\Telematics\TelematicProviderRegistry;
+use Fleetbase\FleetOps\Support\Telematics\TelematicService;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Validation\ValidationException;
+
+/**
+ * Covers the TelematicService persistence pipeline against SQLite: device
+ * linking with identity validation, device event storage with telemetry
+ * field mapping, sensor storage with identity fallbacks and default
+ * locations, device filtering, connection test recording, credential
+ * decryption fallbacks, payload device resolution, and webhook telematic
+ * resolution by integration id, account id, and device id.
+ */
+function fleetopsTelematicServiceBoot(): SQLiteConnection
+{
+    $pdo = new PDO('sqlite::memory:');
+    $pdo->sqliteCreateFunction('ST_PointFromText', fn ($wkt, $srid = 0, $axisOrder = null) => $wkt);
+    $pdo->sqliteCreateFunction('ST_GeomFromText', fn ($wkt, $srid = 0, $axisOrder = null) => $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');
+
+    app()->instance('encrypter', new class {
+        public function encryptString($value)
+        {
+            return base64_encode((string) $value);
+        }
+
+        public function decryptString($value)
+        {
+            $decoded = base64_decode((string) $value, true);
+            if ($decoded === false) {
+                throw new RuntimeException('Unable to decrypt.');
+            }
+
+            return $decoded;
+        }
+
+        public function __call($method, $arguments)
+        {
+            return null;
+        }
+    });
+    Illuminate\Support\Facades\Crypt::clearResolvedInstance('encrypter');
+
+    $schema = $connection->getSchemaBuilder();
+    $tables = [
+        'telematics'    => ['uuid', 'public_id', 'company_uuid', 'provider', 'name', 'credentials', 'status', 'meta', '_key'],
+        'devices'       => ['uuid', 'public_id', 'company_uuid', 'telematic_uuid', 'device_id', 'internal_id', 'imei', 'name', 'status', 'online', 'location', 'meta', 'device_type', 'device_provider', 'last_seen_at', 'attachable_uuid', 'attachable_type', '_key', 'serial_number', 'model', 'manufacturer', 'connection_status', 'provider', 'last_position', 'last_online_at', 'type'],
+        'device_events' => ['uuid', 'public_id', 'company_uuid', 'device_uuid', 'event_type', 'severity', 'message', 'provider', 'ident', 'code', 'state', 'reason', 'occurred_at', 'data', 'payload', 'meta', 'location', '_key', 'processed_at'],
+        'sensors'       => ['uuid', 'public_id', 'company_uuid', 'telematic_uuid', 'device_uuid', 'type', 'internal_id', 'name', 'unit', 'last_value', 'last_reading_at', 'status', 'meta', 'last_position', 'sensor_type', 'min_threshold', 'max_threshold'],
+        'vehicles'      => ['uuid', 'public_id', 'company_uuid', 'name', 'location', 'online', 'heading', 'speed', 'altitude', 'meta'],
+        'positions'     => ['uuid', 'public_id', 'company_uuid', 'subject_uuid', 'subject_type', 'coordinates', 'heading', 'speed', 'altitude', '_key'],
+        'alerts'        => ['uuid', 'public_id', 'company_uuid', 'type', 'severity', 'status', 'subject_type', 'subject_uuid', 'message', 'context', 'triggered_at', 'resolved_at'],
+    ];
+    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']);
+
+    return $connection;
+}
+
+function fleetopsTelematicServiceTelematic(): Telematic
+{
+    $telematic = new Telematic();
+    $telematic->setRawAttributes([
+        'uuid'         => 'tm-1',
+        'public_id'    => 'telematic_test',
+        'company_uuid' => 'company-1',
+        'provider'     => 'traccar',
+        'name'         => 'Traccar Server',
+    ], true);
+    $telematic->exists = true;
+
+    return $telematic;
+}
+
+function fleetopsTelematicService(): TelematicService
+{
+    return new TelematicService(new TelematicProviderRegistry());
+}
+
+test('link device validates identity and reconciles telemetry', function () {
+    $connection = fleetopsTelematicServiceBoot();
+    $service    = fleetopsTelematicService();
+    $telematic  = fleetopsTelematicServiceTelematic();
+
+    expect(fn () => $service->linkDevice($telematic, []))->toThrow(ValidationException::class);
+
+    $device = $service->linkDevice($telematic, [
+        'device_id' => 'unit-9',
+        'name'      => 'Tracker Nine',
+        'online'    => true,
+    ]);
+
+    expect($device)->toBeInstanceOf(Device::class)
+        ->and($connection->table('devices')->count())->toBe(1)
+        ->and($connection->table('devices')->value('device_id'))->toBe('unit-9');
+
+    // Linking the same external id updates rather than duplicates
+    $service->linkDevice($telematic, ['device_id' => 'unit-9', 'name' => 'Tracker Nine Renamed']);
+    expect($connection->table('devices')->count())->toBe(1);
+});
+
+test('store device event maps telemetry fields and links the device', function () {
+    $connection = fleetopsTelematicServiceBoot();
+    $service    = fleetopsTelematicService();
+    $telematic  = fleetopsTelematicServiceTelematic();
+
+    $device = $service->linkDevice($telematic, ['device_id' => 'unit-9']);
+
+    $event = $service->storeDeviceEvent($telematic, [
+        'event_type'  => 'position_update',
+        'severity'    => 'info',
+        'event_id'    => 'evt-1',
+        'speed'       => 42,
+        'heading'     => 180,
+        'ignition'    => true,
+        'occurred_at' => '2026-07-28 08:00:00',
+        'location'    => ['latitude' => 1, 'longitude' => 2],
+    ], $device);
+
+    expect($event->exists)->toBeTrue()
+        ->and($connection->table('device_events')->count())->toBe(1)
+        ->and($event->event_type)->toBe('position_update')
+        ->and($event->ident)->toBe('evt-1');
+
+    // Payload-resolved devices attach without an explicit device
+    $second = $service->storeDeviceEvent($telematic, ['device_id' => 'unit-9', 'event_type' => 'ignition_on', 'reason' => 'ignition']);
+    expect($second->device_uuid)->toBe($device->uuid);
+});
+
+test('store sensor validates identity applies defaults and updates', function () {
+    $connection = fleetopsTelematicServiceBoot();
+    $service    = fleetopsTelematicService();
+    $telematic  = fleetopsTelematicServiceTelematic();
+
+    expect(fn () => $service->storeSensor($telematic, []))->toThrow(ValidationException::class);
+
+    $sensor = $service->storeSensor($telematic, [
+        'sensor_id' => 'sensor-9',
+        'type'      => 'temperature',
+        'name'      => 'Cold Chain',
+        'unit'      => 'C',
+        'value'     => 4.5,
+    ]);
+
+    expect($sensor)->toBeInstanceOf(Sensor::class)
+        ->and($connection->table('sensors')->count())->toBe(1)
+        ->and($connection->table('sensors')->value('last_value'))->toBe('4.5');
+
+    // Device-linked sensors resolve identity from the device
+    $device = $service->linkDevice($telematic, ['device_id' => 'unit-9']);
+    $linked = $service->storeSensor($telematic, ['type' => 'fuel'], $device);
+    expect($linked->device_uuid)->toBe($device->uuid);
+
+    // A reading carrying coordinates keeps them instead of the (0, 0) default
+    $located = $service->storeSensor($telematic, [
+        'sensor_id' => 'sensor-10',
+        'type'      => 'gps',
+        'location'  => ['lat' => '1.29', 'lng' => '103.85'],
+    ]);
+    expect($located->last_position->getLat())->toBe(1.29)
+        ->and($located->last_position->getLng())->toBe(103.85);
+});
+
+test('get devices filters by status and search terms', function () {
+    $connection = fleetopsTelematicServiceBoot();
+    $service    = fleetopsTelematicService();
+    $telematic  = fleetopsTelematicServiceTelematic();
+
+    $connection->table('devices')->insert([
+        ['uuid' => 'device-1', 'telematic_uuid' => 'tm-1', 'device_id' => 'unit-1', 'name' => 'Alpha Tracker', 'status' => 'active'],
+        ['uuid' => 'device-2', 'telematic_uuid' => 'tm-1', 'device_id' => 'unit-2', 'name' => 'Beta Tracker', 'status' => 'disabled'],
+    ]);
+
+    expect($service->getDevices($telematic))->toHaveCount(2)
+        ->and($service->getDevices($telematic, ['status' => 'active']))->toHaveCount(1)
+        ->and($service->getDevices($telematic, ['search' => 'Beta']))->toHaveCount(1)
+        ->and($service->getDevices($telematic, ['search' => 'unit-1']))->toHaveCount(1);
+});
+
+test('connection tests and credentials round trip through the service', function () {
+    $connection = fleetopsTelematicServiceBoot();
+    $service    = fleetopsTelematicService();
+    $connection->table('telematics')->insert(['uuid' => 'tm-1', 'public_id' => 'telematic_test', 'company_uuid' => 'company-1', 'provider' => 'traccar']);
+    $telematic = Telematic::where('uuid', 'tm-1')->withoutGlobalScopes()->first();
+
+    $service->recordConnectionTest($telematic, ['success' => true, 'metadata' => ['latency' => 20]]);
+    expect($connection->table('telematics')->value('status'))->toBe('connected');
+
+    $service->recordConnectionTest($telematic, ['success' => false, 'message' => 'refused']);
+    expect($connection->table('telematics')->value('status'))->toBe('error');
+
+    // Array credentials pass through; json strings fall back after failed
+    // decryption; empty credentials return an empty array
+    $telematic->credentials = null;
+    expect($service->getCredentials($telematic))->toBe([]);
+
+    $plain              = fleetopsTelematicServiceTelematic();
+    $plain->credentials = json_encode(['token' => 'abc']);
+    expect($service->getCredentials($plain))->toBe(['token' => 'abc']);
+});
+
+test('webhook telematics resolve by integration account and device ids', function () {
+    $connection = fleetopsTelematicServiceBoot();
+    $service    = fleetopsTelematicService();
+
+    $connection->table('telematics')->insert([
+        ['uuid' => 'tm-1', 'public_id' => 'telematic_hook', 'company_uuid' => 'company-1', 'provider' => 'traccar', 'meta' => json_encode(['provider_account_id' => 'acct-1'])],
+        ['uuid' => 'tm-2', 'public_id' => 'telematic_other', 'company_uuid' => 'company-1', 'provider' => 'traccar', 'meta' => json_encode([])],
+    ]);
+    $connection->table('devices')->insert(['uuid' => 'device-1', 'telematic_uuid' => 'tm-2', 'device_id' => 'unit-77']);
+
+    // Integration id wins outright
+    expect($service->resolveWebhookTelematic('traccar', [], [], 'telematic_hook')?->uuid)->toBe('tm-1')
+        // Account id metadata matches a single telematic
+        ->and($service->resolveWebhookTelematic('traccar', ['account_id' => 'acct-1'])?->uuid)->toBe('tm-1')
+        // Device identity resolves through the device relation
+        ->and($service->resolveWebhookTelematic('traccar', ['device_id' => 'unit-77'])?->uuid)->toBe('tm-2')
+        // Nothing matches
+        ->and($service->resolveWebhookTelematic('traccar', ['device_id' => 'unit-none']))->toBeNull();
+});

package/server/tests/Unit/Support/Telematics/Providers/AbstractProviderTest.php

@@ -0,0 +1,154 @@
+<?php
+
+use Fleetbase\FleetOps\Exceptions\TelematicRateLimitExceededException;
+use Fleetbase\FleetOps\Models\Telematic;
+use Fleetbase\FleetOps\Support\Telematics\Providers\AbstractProvider;
+use Illuminate\Cache\ArrayStore;
+use Illuminate\Cache\Repository;
+use Illuminate\Http\Client\Factory as HttpFactory;
+use Illuminate\Support\Facades\Cache;
+use Illuminate\Support\Facades\Http;
+
+class FleetOpsAbstractTelematicProviderProbe extends AbstractProvider
+{
+    public function __construct()
+    {
+        $this->baseUrl = 'https://provider.test';
+        $this->headers = ['Authorization' => 'Bearer test-token'];
+    }
+
+    public function requestForTest(string $method, string $endpoint, array $data = []): array
+    {
+        return $this->request($method, $endpoint, $data);
+    }
+
+    public function recordRequestForTest(): void
+    {
+        $this->recordRequest();
+    }
+
+    public function rateLimitKeyForTest(): string
+    {
+        return $this->rateLimitKey();
+    }
+
+    public function testConnection(array $credentials): array
+    {
+        return ['success' => true, 'message' => 'ok', 'metadata' => $credentials];
+    }
+
+    public function fetchDevices(array $options = []): array
+    {
+        return ['devices' => [], 'next_cursor' => null, 'has_more' => false];
+    }
+
+    public function fetchDeviceDetails(string $externalId): array
+    {
+        return ['external_id' => $externalId];
+    }
+
+    public function normalizeDevice(array $payload): array
+    {
+        return $payload;
+    }
+
+    public function normalizeEvent(array $payload): array
+    {
+        return $payload;
+    }
+
+    public function normalizeSensor(array $payload): array
+    {
+        return $payload;
+    }
+
+    protected function prepareAuthentication(): void
+    {
+    }
+}
+
+function fleetopsAbstractProviderUseArrayCache(): void
+{
+    Cache::swap(new Repository(new ArrayStore()));
+}
+
+function fleetopsAbstractProviderTelematic(): Telematic
+{
+    $telematic = new Telematic();
+    $telematic->setRawAttributes([
+        'uuid'        => 'telematic-provider',
+        'credentials' => ['token' => 'array-token'],
+    ], true);
+
+    return $telematic;
+}
+
+test('abstract provider makes authenticated requests and refills rate tokens', function () {
+    fleetopsAbstractProviderUseArrayCache();
+
+    $requests = [];
+    Http::fake(function ($request) use (&$requests) {
+        $requests[] = [
+            'method'        => $request->method(),
+            'url'           => (string) $request->url(),
+            'authorization' => $request->header('Authorization'),
+            'data'          => $request->data(),
+        ];
+
+        return Http::response(['ok' => true, 'devices' => [['id' => 'device-1']]], 200);
+    });
+
+    $provider = new FleetOpsAbstractTelematicProviderProbe();
+    $provider->connect(fleetopsAbstractProviderTelematic());
+
+    $result = $provider->requestForTest('POST', '/devices', ['limit' => 10]);
+
+    expect($result)->toBe(['ok' => true, 'devices' => [['id' => 'device-1']]])
+        ->and($requests)->toBe([
+            [
+                'method'        => 'POST',
+                'url'           => 'https://provider.test/devices',
+                'authorization' => ['Bearer test-token'],
+                'data'          => ['limit' => 10],
+            ],
+        ])
+        ->and(Cache::get($provider->rateLimitKeyForTest()))->toBe(10);
+});
+
+test('abstract provider rejects exhausted rate limit buckets and failed responses', function () {
+    fleetopsAbstractProviderUseArrayCache();
+
+    $provider = new FleetOpsAbstractTelematicProviderProbe();
+    $provider->connect(fleetopsAbstractProviderTelematic());
+    Cache::put($provider->rateLimitKeyForTest(), 0, 60);
+
+    expect(fn () => $provider->requestForTest('GET', '/blocked'))
+        ->toThrow(TelematicRateLimitExceededException::class, 'Rate limit exceeded for provider');
+
+    fleetopsAbstractProviderUseArrayCache();
+    Http::swap(new HttpFactory());
+    Http::fake(fn () => Http::response(['error' => true], 503));
+
+    $provider = new FleetOpsAbstractTelematicProviderProbe();
+    $provider->connect(fleetopsAbstractProviderTelematic());
+
+    expect(fn () => $provider->requestForTest('GET', '/failure'))
+        ->toThrow(Exception::class, 'Provider API request failed with status 503');
+});
+
+test('abstract provider caps gradual rate limit refill at burst size', function () {
+    fleetopsAbstractProviderUseArrayCache();
+
+    $provider = new FleetOpsAbstractTelematicProviderProbe();
+    $provider->connect(fleetopsAbstractProviderTelematic());
+
+    Cache::put($provider->rateLimitKeyForTest(), 7, 60);
+    $provider->recordRequestForTest();
+
+    expect(Cache::get($provider->rateLimitKeyForTest()))->toBe(8);
+
+    Cache::put($provider->rateLimitKeyForTest(), 10, 60);
+    $provider->recordRequestForTest();
+
+    expect(Cache::get($provider->rateLimitKeyForTest()))->toBe(10);
+});

package/server/tests/Unit/Support/Telematics/Providers/AfaqyProviderTest.php

@@ -0,0 +1,191 @@
+<?php
+
+use Fleetbase\FleetOps\Support\Telematics\Providers\AfaqyProvider;
+
+class FleetOpsAfaqyProviderUnitProbe extends AfaqyProvider
+{
+    public array $postCalls          = [];
+    public array $responses          = [];
+    public ?Throwable $postException = null;
+    public ?string $authToken        = 'authenticated-token';
+    public int $authentications      = 0;
+
+    public function setCredentialsForTest(array $credentials): void
+    {
+        $this->credentials = $credentials;
+    }
+
+    public function credentialsForTest(): array
+    {
+        return $this->credentials;
+    }
+
+    public function headersForTest(): array
+    {
+        return $this->headers;
+    }
+
+    public function baseUrlForTest(): string
+    {
+        return $this->baseUrl;
+    }
+
+    public function prepareAuthenticationForTest(): void
+    {
+        $this->prepareAuthentication();
+    }
+
+    public function queuePostResponse(array $response): void
+    {
+        $this->responses[] = $response;
+    }
+
+    protected function authenticate(): string
+    {
+        $this->authentications++;
+
+        if (!$this->authToken) {
+            throw new InvalidArgumentException('AFAQY username/password or token is required.');
+        }
+
+        return $this->authToken;
+    }
+
+    protected function afaqyPost(string $endpoint, array $payload = [], bool $tokenInQuery = false, ?int $timeout = null, ?int $connectTimeout = null): array
+    {
+        $this->postCalls[] = [$endpoint, $payload, $tokenInQuery, $timeout, $connectTimeout];
+
+        if ($this->postException) {
+            throw $this->postException;
+        }
+
+        return array_shift($this->responses) ?? [];
+    }
+}
+
+function fleetopsAfaqyProviderUnit(array $credentials = []): FleetOpsAfaqyProviderUnitProbe
+{
+    $provider = new FleetOpsAfaqyProviderUnitProbe();
+    $provider->setCredentialsForTest($credentials);
+
+    return $provider;
+}
+
+test('afaqy provider prepares token authentication and custom base urls', function () {
+    $staticToken = fleetopsAfaqyProviderUnit([
+        'base_url' => 'https://afaqy.example.test/',
+        'token'    => 'static-token',
+    ]);
+    $staticToken->prepareAuthenticationForTest();
+
+    expect($staticToken->baseUrlForTest())->toBe('https://afaqy.example.test')
+        ->and($staticToken->credentialsForTest()['token'])->toBe('static-token')
+        ->and($staticToken->headersForTest())->toBe([
+            'Accept'        => 'application/json',
+            'Content-Type'  => 'application/json',
+            'Authorization' => 'Bearer static-token',
+        ])
+        ->and($staticToken->authentications)->toBe(0);
+
+    $refreshable = fleetopsAfaqyProviderUnit([
+        'username' => 'unit-user',
+        'password' => 'unit-secret',
+    ]);
+    $refreshable->prepareAuthenticationForTest();
+
+    expect($refreshable->credentialsForTest()['token'])->toBe('authenticated-token')
+        ->and($refreshable->authentications)->toBe(1);
+
+    expect(fn () => fleetopsAfaqyProviderUnit()->prepareAuthenticationForTest())
+        ->toThrow(InvalidArgumentException::class, 'AFAQY username/password or token is required.');
+});
+
+test('afaqy provider tests connections with timeout settings and failure metadata', function () {
+    $success = fleetopsAfaqyProviderUnit(['token' => 'static-token']);
+    $success->queuePostResponse([
+        'data'        => [['id' => 'unit-1'], ['id' => 'unit-2']],
+        'status_code' => 200,
+    ]);
+
+    expect($success->testConnection(['token' => 'static-token']))->toBe([
+        'success'  => true,
+        'message'  => 'Connection successful',
+        'metadata' => [
+            'units_count' => 2,
+            'status_code' => 200,
+        ],
+    ])
+        ->and($success->postCalls)->toHaveCount(1)
+        ->and($success->postCalls[0][0])->toBe('/units/lists')
+        ->and($success->postCalls[0][2])->toBeTrue()
+        ->and($success->postCalls[0][3])->toBe(30)
+        ->and($success->postCalls[0][4])->toBe(10);
+
+    $failure                = fleetopsAfaqyProviderUnit();
+    $failure->postException = new RuntimeException('provider unavailable');
+
+    expect($failure->testConnection(['token' => 'static-token']))->toBe([
+        'success'  => false,
+        'message'  => 'provider unavailable',
+        'metadata' => [],
+    ]);
+});
+
+test('afaqy provider fetches paginated devices details and credential schema', function () {
+    $provider = fleetopsAfaqyProviderUnit(['token' => 'static-token']);
+    $provider->queuePostResponse([
+        'data' => [
+            ['_id' => 'unit-1', 'name' => 'Unit 1'],
+            ['_id' => 'unit-2', 'name' => 'Unit 2'],
+        ],
+        'pagination' => [
+            'offset'       => 10,
+            'limit'        => 2,
+            'resultCount'  => 2,
+            'filtersCount' => 20,
+            'allCount'     => 30,
+        ],
+    ]);
+    $provider->queuePostResponse([
+        'data' => ['_id' => 'unit-1', 'name' => 'Unit 1'],
+    ]);
+
+    $devices = $provider->fetchDevices([
+        'limit'   => 1000,
+        'cursor'  => 10,
+        'filters' => [],
+        'address' => true,
+    ]);
+    $details = $provider->fetchDeviceDetails('unit-1');
+
+    expect($devices)->toMatchArray([
+        'devices'     => [
+            ['_id' => 'unit-1', 'name' => 'Unit 1'],
+            ['_id' => 'unit-2', 'name' => 'Unit 2'],
+        ],
+        'next_cursor' => 12,
+        'has_more'    => true,
+        'pagination'  => [
+            'allCount'     => 30,
+            'filtersCount' => 20,
+            'resultCount'  => 2,
+            'offset'       => 10,
+            'limit'        => 2,
+        ],
+    ])
+        ->and($details)->toBe(['_id' => 'unit-1', 'name' => 'Unit 1'])
+        ->and($provider->postCalls[0][0])->toBe('/units/lists')
+        ->and($provider->postCalls[0][1]['data']['limit'])->toBe(500)
+        ->and($provider->postCalls[0][1]['data']['offset'])->toBe(10)
+        ->and($provider->postCalls[0][1]['data']['filters'])->toBeInstanceOf(stdClass::class)
+        ->and($provider->postCalls[0][1]['data']['address'])->toBeTrue()
+        ->and($provider->postCalls[0][2])->toBeTrue()
+        ->and($provider->postCalls[1])->toBe(['/units/view', ['data' => ['id' => 'unit-1']], false, null, null]);
+
+    $schema = $provider->getCredentialSchema();
+
+    expect(array_column($schema, 'name'))->toBe(['base_url', 'username', 'password', 'token'])
+        ->and($schema[0]['default_value'])->toBe('https://api.afaqy.sa')
+        ->and($schema[1]['validation'])->toBe('required_without:token|string')
+        ->and($schema[3]['validation'])->toBe('required_without:username|string');
+});