@fleetbase/fleetops-engine 0.6.57 → 0.6.59

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

@@ -0,0 +1,163 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Controllers\Api\v1\ContactController;
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\PositionController;
+use Fleetbase\FleetOps\Models\Contact;
+use Fleetbase\TestSupport\DispatchRecorder;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Http\Request;
+
+/**
+ * Covers the internal PositionController replay and metrics endpoints and
+ * the API ContactController protected helpers against SQLite: replay input
+ * guards with job dispatch, metric calculation over stored positions, and
+ * contact input normalization, persistence, lookup, and resource wrappers.
+ */
+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\FleetOps\Http\Controllers\Internal\v1\dispatch')) {
+    eval('namespace Fleetbase\FleetOps\Http\Controllers\Internal\v1; function dispatch($job = null) { \Fleetbase\TestSupport\DispatchRecorder::$dispatched[] = $job; return new \Fleetbase\TestSupport\PendingDispatch(); }');
+}
+
+class FleetOpsApiContactHelpersProbe extends ContactController
+{
+    public function callHelper(string $method, ...$arguments): mixed
+    {
+        return $this->{$method}(...$arguments);
+    }
+}
+
+function fleetopsPositionReplayBoot(): 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');
+
+    $schema = $connection->getSchemaBuilder();
+    app()->instance('db.schema', $schema);
+    $tables = [
+        'positions' => ['uuid', 'public_id', 'company_uuid', 'subject_uuid', 'subject_type', 'destination_uuid', 'coordinates', 'heading', 'bearing', 'speed', 'altitude', 'order_uuid', '_key'],
+        'contacts'  => ['uuid', 'public_id', 'internal_id', 'company_uuid', 'user_uuid', 'place_uuid', 'name', 'title', 'email', 'phone', 'type', 'meta', 'slug', '_key'],
+        'users'     => ['uuid', 'public_id', 'company_uuid', 'name', 'email', 'type', 'status'],
+        'places'    => ['uuid', 'public_id', 'company_uuid', 'owner_uuid', 'name'],
+    ];
+    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']);
+    DispatchRecorder::$dispatched = [];
+
+    return $connection;
+}
+
+function fleetopsPositionReplayWkb(float $latitude, float $longitude): string
+{
+    return pack('V', 0) . pack('C', 1) . pack('V', 1) . pack('d', $longitude) . pack('d', $latitude);
+}
+
+test('replay validates inputs and dispatches the replay job', function () {
+    $connection = fleetopsPositionReplayBoot();
+    $controller = new PositionController();
+
+    expect($controller->replay(Request::create('/x', 'POST', []))->getData(true)['error'])->toContain('Channel ID');
+    expect($controller->replay(Request::create('/x', 'POST', ['channel_id' => 'chan-1']))->getData(true)['error'])->toContain('Position IDs');
+    expect($controller->replay(Request::create('/x', 'POST', ['channel_id' => 'chan-1', 'position_ids' => ['missing']]))->getData(true)['error'])->toContain('No positions found');
+
+    $connection->table('positions')->insert([
+        ['uuid' => 'pos-1', 'company_uuid' => 'company-1', 'subject_uuid' => 'driver-1', 'coordinates' => fleetopsPositionReplayWkb(1.30, 103.80), 'speed' => '10', 'created_at' => '2026-07-28 08:00:00'],
+        ['uuid' => 'pos-2', 'company_uuid' => 'company-1', 'subject_uuid' => 'driver-1', 'coordinates' => fleetopsPositionReplayWkb(1.31, 103.81), 'speed' => '12', 'created_at' => '2026-07-28 08:00:10'],
+    ]);
+
+    $response = $controller->replay(Request::create('/x', 'POST', ['channel_id' => 'chan-1', 'position_ids' => ['pos-1', 'pos-2'], 'speed' => 2]));
+
+    expect($response->getData(true)['status'])->toBe('ok')
+        ->and($response->getData(true)['total_positions'])->toBe(2)
+        ->and(DispatchRecorder::$dispatched)->toHaveCount(1);
+});
+
+test('metrics validates inputs and calculates over stored positions', function () {
+    $connection = fleetopsPositionReplayBoot();
+    $controller = new PositionController();
+
+    expect($controller->metrics(Request::create('/x', 'POST', []))->getData(true)['error'])->toContain('Position IDs');
+    expect($controller->metrics(Request::create('/x', 'POST', ['position_ids' => ['missing']]))->getData(true)['metrics'])->toBe([]);
+
+    $connection->table('positions')->insert([
+        ['uuid' => 'pos-1', 'company_uuid' => 'company-1', 'coordinates' => fleetopsPositionReplayWkb(1.30, 103.80), 'speed' => '10', 'altitude' => '5', 'created_at' => '2026-07-28 08:00:00'],
+        ['uuid' => 'pos-2', 'company_uuid' => 'company-1', 'coordinates' => fleetopsPositionReplayWkb(1.31, 103.81), 'speed' => '20', 'altitude' => '15', 'created_at' => '2026-07-28 08:10:00'],
+    ]);
+
+    $metrics = $controller->metrics(Request::create('/x', 'POST', ['position_ids' => ['pos-1', 'pos-2']]))->getData(true)['metrics'];
+
+    expect($metrics)->toBeArray()->not->toBeEmpty();
+});
+
+test('contact helpers normalize input persist and resolve records', function () {
+    $connection = fleetopsPositionReplayBoot();
+    $probe      = new FleetOpsApiContactHelpersProbe();
+
+    $input = $probe->callHelper('contactCreateInputFromRequest', Request::create('/x', 'POST', ['name' => 'Api Contact', 'phone' => '+65 9123 4567']));
+    expect($input['type'])->toBe('contact')
+        ->and($input['name'])->toBe('Api Contact');
+
+    $updateInput = $probe->callHelper('contactUpdateInputFromRequest', Request::create('/x', 'POST', ['name' => 'Renamed', 'title' => 'Ops']));
+    expect($updateInput)->toBe(['name' => 'Renamed', 'title' => 'Ops']);
+
+    expect($probe->callHelper('newContact', [['name' => 'Fresh']]))->toBeInstanceOf(Contact::class);
+
+    $contact = $probe->callHelper('updateOrCreateContact', ['email' => 'api@example.test'], ['company_uuid' => 'company-1', 'name' => 'Upserted', 'type' => 'contact']);
+    expect($contact)->toBeInstanceOf(Contact::class)
+        ->and($connection->table('contacts')->count())->toBe(1);
+
+    $connection->table('contacts')->update(['public_id' => 'contact_api1234']);
+    $found = $probe->callHelper('findContact', 'contact_api1234');
+    expect($found)->toBeInstanceOf(Contact::class);
+
+    expect($probe->callHelper('getPlaceUuid', 'places', ['uuid' => 'missing']))->toBeNull()
+        ->and($probe->callHelper('findRelatedUser', $contact))->toBeNull()
+        ->and($probe->callHelper('contactResource', $contact))->not->toBeNull()
+        ->and($probe->callHelper('contactResourceCollection', collect([$contact])))->not->toBeNull()
+        ->and($probe->callHelper('deletedContactResource', $contact))->not->toBeNull();
+
+    $json = $probe->callHelper('jsonResponse', ['ok' => true], 201);
+    expect($json->getStatusCode())->toBe(201);
+
+    $error = $probe->callHelper('apiError', 'nope', 422);
+    expect($error->getStatusCode())->toBe(422);
+});

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

@@ -0,0 +1,219 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\ProofController;
+use Fleetbase\FleetOps\Models\Proof;
+use Illuminate\Http\Request;
+
+class FleetOpsProofControllerProbe extends ProofController
+{
+    public array $qrSubjects       = [];
+    public array $publicSubjects   = [];
+    public array $createdProofs    = [];
+    public array $storedSignatures = [];
+    public array $createdFiles     = [];
+
+    public function callHelper(string $method, mixed ...$arguments): mixed
+    {
+        $reflection = new ReflectionMethod(ProofController::class, $method);
+        $reflection->setAccessible(true);
+
+        return $reflection->invoke($this, ...$arguments);
+    }
+
+    protected function findQrSubject(string $type, ?string $code): mixed
+    {
+        return $this->qrSubjects[$type . ':' . $code] ?? null;
+    }
+
+    protected function findPublicSubject(string $type, string $publicId): mixed
+    {
+        return $this->publicSubjects[$type . ':' . $publicId] ?? null;
+    }
+
+    protected function createProof(array $attributes): Proof
+    {
+        $this->createdProofs[] = $attributes;
+
+        $proof = new FleetOpsProofControllerProofFake();
+        $proof->setRawAttributes([
+            'uuid'      => 'proof-uuid-' . count($this->createdProofs),
+            'public_id' => 'proof-public-' . count($this->createdProofs),
+        ], true);
+
+        return $proof;
+    }
+
+    protected function storeSignature(string $path, string|false $contents, string $visibility): void
+    {
+        $this->storedSignatures[] = [$path, $contents, $visibility];
+    }
+
+    protected function createSignatureFile(string $path, string $signature, Proof $proof): Fleetbase\Models\File
+    {
+        $this->createdFiles[] = [$path, $signature, $proof->public_id];
+
+        $file = new FleetOpsProofControllerFileFake();
+        $file->setRawAttributes(['uuid' => 'file-uuid'], true);
+
+        return $file;
+    }
+
+    protected function jsonResponse(array $payload): array
+    {
+        return ['json' => $payload];
+    }
+
+    protected function errorResponse(string $message): array
+    {
+        return ['error' => $message];
+    }
+}
+
+class FleetOpsProofControllerProofFake extends Proof
+{
+    public bool $saved = false;
+
+    public function save(array $options = []): bool
+    {
+        $this->saved = true;
+
+        return true;
+    }
+}
+
+class FleetOpsProofControllerFileFake extends Fleetbase\Models\File
+{
+    public array $keys = [];
+
+    public function setKey($model, $type = null): Fleetbase\Models\File
+    {
+        $this->keys[] = $model->public_id;
+
+        return $this;
+    }
+}
+
+test('internal proof controller builds success signature path and file metadata helpers', function () {
+    session([
+        'company' => 'company-uuid',
+        'user'    => 'user-uuid',
+    ]);
+    app('config')->set('filesystems.disks.s3.bucket', 'fleetbase-test-bucket');
+
+    $controller = new FleetOpsProofControllerProbe();
+    $proof      = new Proof();
+    $proof->setRawAttributes(['public_id' => 'proof-public'], true);
+    $signature = base64_encode('signature-bytes');
+
+    $path = $controller->callHelper('signatureStoragePath', $proof);
+
+    expect($controller->callHelper('proofSuccessPayload', $proof))->toBe([
+        'status' => 'success',
+        'proof'  => 'proof-public',
+    ])->and($path)->toBe('uploads/company-uuid/signatures/proof-public.png')
+        ->and($controller->callHelper('signatureFileAttributes', $path, $signature))->toBe([
+            'company_uuid'      => 'company-uuid',
+            'uploader_uuid'     => 'user-uuid',
+            'name'              => 'proof-public.png',
+            'original_filename' => 'proof-public.png',
+            'extension'         => 'png',
+            'content_type'      => 'image/png',
+            'path'              => 'uploads/company-uuid/signatures/proof-public.png',
+            'bucket'            => 'fleetbase-test-bucket',
+            'type'              => 'signature',
+            'size'              => 15,
+        ]);
+});
+
+test('internal proof controller verifies qr code subjects and handles validation failures', function () {
+    session(['company' => 'company-uuid']);
+
+    $controller = new FleetOpsProofControllerProbe();
+    $subject    = new Fleetbase\FleetOps\Models\Order();
+    $subject->setRawAttributes([
+        'uuid'      => 'order-uuid',
+        'public_id' => 'order_public',
+    ], true);
+
+    $controller->qrSubjects['order:order-uuid'] = $subject;
+
+    $response = $controller->verifyQrCode('order_public', new Request([
+        'type'     => 'order',
+        'code'     => 'order-uuid',
+        'raw_data' => 'raw scan',
+        'data'     => ['lat' => 1],
+    ]));
+
+    expect($response)->toBe([
+        'json' => [
+            'status' => 'success',
+            'proof'  => 'proof-public-1',
+        ],
+    ])->and($controller->createdProofs)->toHaveCount(1)
+        ->and($controller->createdProofs[0])->toMatchArray([
+            'company_uuid' => 'company-uuid',
+            'subject_uuid' => 'order-uuid',
+            'subject_type' => '\Fleetbase\FleetOps\Models\Order',
+            'remarks'      => 'Verified by QR Code Scan',
+            'raw_data'     => 'raw scan',
+            'data'         => ['lat' => 1],
+        ]);
+
+    expect($controller->verifyQrCode('order_public', new Request([
+        'type' => 'order',
+        'code' => 'missing',
+    ])))->toBe(['error' => 'Unable to validate QR code data.']);
+
+    expect($controller->verifyQrCode('other_public', new Request([
+        'type' => 'order',
+        'code' => 'order-uuid',
+    ])))->toBe(['error' => 'Unable to validate QR code data.']);
+});
+
+test('internal proof controller captures signatures and assigns uploaded file', function () {
+    session([
+        'company' => 'company-uuid',
+        'user'    => 'user-uuid',
+    ]);
+    app('config')->set('filesystems.disks.s3.bucket', 'fleetbase-test-bucket');
+
+    $controller = new FleetOpsProofControllerProbe();
+    $subject    = new Fleetbase\FleetOps\Models\Waypoint();
+    $subject->setRawAttributes([
+        'uuid'      => 'waypoint-uuid',
+        'public_id' => 'waypoint_public',
+    ], true);
+
+    $controller->publicSubjects['waypoint:waypoint_public'] = $subject;
+
+    $signature = base64_encode('signature-bytes');
+    $response  = $controller->captureSignature('waypoint_public', new Request([
+        'type'      => 'waypoint',
+        'signature' => $signature,
+    ]));
+
+    expect($response)->toBe([
+        'json' => [
+            'status' => 'success',
+            'proof'  => 'proof-public-1',
+        ],
+    ])->and($controller->createdProofs)->toHaveCount(1)
+        ->and($controller->createdProofs[0])->toMatchArray([
+            'company_uuid' => 'company-uuid',
+            'subject_uuid' => 'waypoint-uuid',
+            'subject_type' => '\Fleetbase\FleetOps\Models\Waypoint',
+            'remarks'      => 'Verified by Signature',
+            'raw_data'     => $signature,
+        ])
+        ->and($controller->storedSignatures)->toBe([
+            ['uploads/company-uuid/signatures/proof-public-1.png', 'signature-bytes', 'public'],
+        ])
+        ->and($controller->createdFiles)->toBe([
+            ['uploads/company-uuid/signatures/proof-public-1.png', $signature, 'proof-public-1'],
+        ]);
+
+    expect($controller->captureSignature('missing_public', new Request([
+        'type'      => 'waypoint',
+        'signature' => $signature,
+    ])))->toBe(['error' => 'Unable to capture signature data.']);
+});

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

@@ -0,0 +1,151 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\SearchController;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+/**
+ * Covers the internal global search endpoint against SQLite as an admin
+ * session user: empty-query short circuit, requested-type normalization,
+ * the order/driver searches with their relation subqueries, and the
+ * generic column search used by vehicles and fleets.
+ */
+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; } }; }');
+}
+
+function fleetopsSearchEndpointBoot(): 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 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');
+
+    $schema = $connection->getSchemaBuilder();
+    $tables = [
+        'users'            => ['uuid', 'public_id', 'company_uuid', 'name', 'email', 'phone', 'type', 'status'],
+        'orders'           => ['uuid', 'public_id', 'internal_id', 'company_uuid', 'tracking_number_uuid', 'status', 'type'],
+        'tracking_numbers' => ['uuid', 'public_id', 'company_uuid', 'tracking_number', 'barcode', 'owner_uuid'],
+        'drivers'          => ['uuid', 'public_id', 'company_uuid', 'user_uuid', 'drivers_license_number', 'status'],
+        'vehicles'         => ['uuid', 'public_id', 'company_uuid', 'name', 'description', 'make', 'model', 'year', 'internal_id', 'plate_number', 'vin', 'serial_number', 'call_sign'],
+        'fleets'           => ['uuid', 'public_id', 'company_uuid', 'name'],
+    ];
+    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();
+        });
+    }
+
+    // Admin session user bypasses per-type permission checks
+    $connection->table('users')->insert(['uuid' => 'admin-1', 'company_uuid' => 'company-1', 'name' => 'Admin', 'type' => 'admin']);
+    session(['company' => 'company-1', 'user' => 'admin-1']);
+
+    return $connection;
+}
+
+test('search returns empty results for blank queries', function () {
+    fleetopsSearchEndpointBoot();
+
+    $response = (new SearchController())->search(Request::create('/x', 'GET', ['query' => '   ']));
+
+    expect($response)->toBeInstanceOf(JsonResponse::class)
+        ->and($response->getData(true))->toBe(['results' => []]);
+});
+
+test('search finds orders by tracking number and drivers by user name', function () {
+    $connection = fleetopsSearchEndpointBoot();
+    $connection->table('tracking_numbers')->insert(['uuid' => 'tn-1', 'company_uuid' => 'company-1', 'tracking_number' => 'TRK-FINDME-1', 'owner_uuid' => 'order-1']);
+    $connection->table('orders')->insert(['uuid' => 'order-1', 'public_id' => 'order_search', 'company_uuid' => 'company-1', 'tracking_number_uuid' => 'tn-1', 'status' => 'created']);
+    $connection->table('users')->insert(['uuid' => 'user-1', 'company_uuid' => 'company-1', 'name' => 'Findme Driver', 'email' => 'findme@example.test']);
+    $connection->table('drivers')->insert(['uuid' => 'driver-1', 'public_id' => 'driver_search', 'company_uuid' => 'company-1', 'user_uuid' => 'user-1']);
+
+    $response = (new SearchController())->search(Request::create('/x', 'GET', ['query' => 'FINDME', 'types' => 'orders,drivers']));
+    $results  = $response->getData(true)['results'];
+
+    expect(collect($results)->pluck('type')->all())->toContain('Order', 'Driver');
+});
+
+test('search generic types match columns and respect the limit', function () {
+    $connection = fleetopsSearchEndpointBoot();
+    $connection->table('vehicles')->insert(['uuid' => 'vehicle-1', 'public_id' => 'vehicle_search', 'company_uuid' => 'company-1', 'name' => 'Atlas Truck', 'plate_number' => 'ATLAS-99']);
+    $connection->table('fleets')->insert(['uuid' => 'fleet-1', 'public_id' => 'fleet_search', 'company_uuid' => 'company-1', 'name' => 'Atlas Fleet']);
+
+    $response = (new SearchController())->search(Request::create('/x', 'GET', ['q' => 'Atlas', 'types' => 'vehicles,fleets', 'limit' => 5]));
+    $results  = $response->getData(true)['results'];
+
+    expect(collect($results)->pluck('type')->all())->toContain('Vehicle', 'Fleet');
+
+    // Unknown types fall back to the full type list; unmatched queries
+    // return nothing
+    $none = (new SearchController())->search(Request::create('/x', 'GET', ['query' => 'zzz-no-match', 'types' => 'vehicles']));
+    expect($none->getData(true)['results'])->toBe([]);
+});
+
+test('search dispatches every registered type arm', function () {
+    $connection = fleetopsSearchEndpointBoot();
+
+    $schema = $connection->getSchemaBuilder();
+    $extra  = [
+        'vendors'                    => ['uuid', 'public_id', 'company_uuid', 'name', 'email', 'phone', 'business_id', 'status'],
+        'contacts'                   => ['uuid', 'public_id', 'company_uuid', 'name', 'email', 'phone', 'type'],
+        'places'                     => ['uuid', 'public_id', 'company_uuid', 'name', 'street1', 'street2', 'country', 'province', 'district', 'city', 'postal_code', 'phone'],
+        'issues'                     => ['uuid', 'public_id', 'company_uuid', 'issue_id', 'category', 'type', 'report', 'title', 'priority', 'status'],
+        'fuel_reports'               => ['uuid', 'public_id', 'company_uuid', 'report', 'status', 'currency'],
+        'fuel_provider_transactions' => ['uuid', 'public_id', 'company_uuid', 'provider', 'provider_transaction_id', 'vehicle_card_id', 'internal_number', 'plate_number', 'vin', 'serial_number', 'call_sign', 'station_name', 'trip_number', 'sync_status'],
+        'maintenance_schedules'      => ['uuid', 'public_id', 'company_uuid', 'name', 'type', 'status'],
+        'work_orders'                => ['uuid', 'public_id', 'company_uuid', 'code', 'subject', 'category', 'instructions', 'status', 'priority'],
+        'maintenances'               => ['uuid', 'public_id', 'company_uuid', 'summary', 'notes', 'type', 'status', 'priority'],
+        'equipments'                 => ['uuid', 'public_id', 'company_uuid', 'name', 'code', 'type', 'serial_number', 'manufacturer', 'model'],
+        'parts'                      => ['uuid', 'public_id', 'company_uuid', 'sku', 'name', 'manufacturer', 'model', 'serial_number', 'barcode'],
+        'fuel_provider_connections'  => ['uuid', 'public_id', 'company_uuid', 'name', 'provider', 'status', 'environment'],
+        'telematics'                 => ['uuid', 'public_id', 'company_uuid', 'name', 'provider', 'model', 'serial_number', 'imei'],
+        'devices'                    => ['uuid', 'public_id', 'company_uuid', 'name', 'model', 'serial_number', 'manufacturer', 'device_id', 'internal_id', 'imei'],
+        'sensors'                    => ['uuid', 'public_id', 'company_uuid', 'name', 'type', 'internal_id', 'unit'],
+        'device_events'              => ['uuid', 'public_id', 'company_uuid', 'event_type', 'message', 'ident', 'code', 'provider', 'severity'],
+        'service_rates'              => ['uuid', 'public_id', 'company_uuid', 'service_name', 'service_type', 'currency', 'algorithm', 'rate_calculation_method'],
+        'order_configs'              => ['uuid', 'public_id', 'company_uuid', 'name', 'description', 'key', 'namespace', 'status'],
+    ];
+    foreach ($extra 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();
+        });
+    }
+
+    $types = 'orders,drivers,vehicles,fleets,vendors,contacts,places,issues,fuel_reports,fuel_transactions,maintenance_schedules,work_orders,maintenances,equipment,parts,fuel_providers,telematics,devices,sensors,events,service_rates,order_configs';
+
+    $response = (new SearchController())->search(Request::create('/x', 'GET', ['query' => 'anything', 'types' => $types]));
+    expect($response->getData(true))->toBeArray();
+});