@fleetbase/fleetops-engine 0.6.57 → 0.6.59

package/server/tests/IssueTimelineContractsTest.php

@@ -0,0 +1,191 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Controllers\Internal\v1\IssueController;
+use Fleetbase\FleetOps\Models\Issue;
+use Fleetbase\Models\Activity;
+use Illuminate\Support\Carbon;
+
+class FleetOpsIssueControllerProbe extends IssueController
+{
+    public function callHelper(string $method, mixed ...$arguments): mixed
+    {
+        $reflection = new ReflectionMethod(IssueController::class, $method);
+        $reflection->setAccessible(true);
+
+        return $reflection->invoke($this, ...$arguments);
+    }
+}
+
+/**
+ * Supplies file activities directly so the real mapping closure runs without a
+ * database behind the activity-log query.
+ */
+class FleetOpsIssueFileEventsProbe extends IssueController
+{
+    public array $fileActivities = [];
+    public array $currentFiles   = [];
+
+    public function callFileEvents(Issue $issue): Illuminate\Support\Collection
+    {
+        $reflection = new ReflectionMethod(IssueController::class, 'fileEvents');
+        $reflection->setAccessible(true);
+
+        return $reflection->invoke($this, $issue);
+    }
+
+    protected function fileActivitiesForIssue(Issue $issue): Illuminate\Support\Collection
+    {
+        return collect($this->fileActivities);
+    }
+
+    protected function filesForIssue(Issue $issue): Illuminate\Support\Collection
+    {
+        return collect($this->currentFiles);
+    }
+}
+
+function fleetopsTimelineIssue(): Issue
+{
+    $issue = new Issue();
+    $issue->setRawAttributes([
+        'uuid'          => 'issue-uuid',
+        'public_id'     => 'issue-public',
+        'reporter_name' => 'Ada Reporter',
+        'created_at'    => Carbon::parse('2026-01-01 10:00:00'),
+    ], true);
+    $issue->setRelation('reporter', (object) [
+        'name'       => 'Ada Reporter',
+        'avatar_url' => 'https://example.test/reporter.png',
+    ]);
+
+    return $issue;
+}
+
+function fleetopsTimelineActivity(array $attributes = []): Activity
+{
+    $activity = new Activity();
+    $activity->setRawAttributes(array_merge([
+        'uuid'        => 'activity-uuid',
+        'description' => 'Issue was updated.',
+        'created_at'  => Carbon::parse('2026-01-01 11:00:00'),
+    ], $attributes), true);
+    $activity->setRelation('causer', (object) [
+        'name'       => 'Ops Manager',
+        'avatar_url' => 'https://example.test/manager.png',
+    ]);
+
+    return $activity;
+}
+
+test('issue timeline opened and generic activity events include actor and issue metadata', function () {
+    $controller = new FleetOpsIssueControllerProbe();
+    $issue      = fleetopsTimelineIssue();
+    $activity   = fleetopsTimelineActivity();
+
+    $opened  = $controller->callHelper('makeIssueOpenedEvent', $issue);
+    $generic = $controller->callHelper('makeGenericActivityEvent', $activity, $issue);
+
+    expect($opened)->toMatchArray([
+        'id'               => 'issue-uuid-opened',
+        'type'             => 'issue_opened',
+        'label'            => 'Issue opened',
+        'description'      => 'Reported by Ada Reporter',
+        'actor_name'       => 'Ada Reporter',
+        'actor_avatar_url' => 'https://example.test/reporter.png',
+        'icon'             => 'circle-plus',
+        'tone'             => 'green',
+        'meta'             => ['issue_id' => 'issue-public'],
+    ])
+        ->and($generic)->toMatchArray([
+            'id'               => 'activity-uuid',
+            'type'             => 'issue_updated',
+            'label'            => 'Issue updated',
+            'description'      => 'Issue was updated.',
+            'actor_name'       => 'Ops Manager',
+            'actor_avatar_url' => 'https://example.test/manager.png',
+            'icon'             => 'pen',
+            'tone'             => 'slate',
+            'meta'             => ['issue_id' => 'issue-public'],
+        ]);
+});
+
+test('issue timeline field events map important field changes to specialized labels', function () {
+    $controller = new FleetOpsIssueControllerProbe();
+    $issue      = fleetopsTimelineIssue();
+    $activity   = fleetopsTimelineActivity(['id' => 123, 'uuid' => null]);
+
+    $closed   = $controller->callHelper('makeFieldChangedEvent', $activity, $issue, 'status', 'open', 'resolved');
+    $reopened = $controller->callHelper('makeFieldChangedEvent', $activity, $issue, 'status', 'resolved', 're_opened');
+    $assignee = $controller->callHelper('makeFieldChangedEvent', $activity, $issue, 'assigned_to_uuid', null, 'user-uuid');
+    $category = $controller->callHelper('makeFieldChangedEvent', $activity, $issue, 'category', 'damage', 'delay');
+
+    expect($closed)->toMatchArray([
+        'id'          => '123-status',
+        'type'        => 'issue_closed',
+        'label'       => 'Issue closed',
+        'description' => 'Status changed from Open to Resolved.',
+        'icon'        => 'circle-check',
+        'tone'        => 'green',
+        'meta'        => [
+            'field'    => 'status',
+            'from'     => 'open',
+            'to'       => 'resolved',
+            'issue_id' => 'issue-public',
+        ],
+    ])
+        ->and($reopened)->toMatchArray([
+            'type'  => 'issue_reopened',
+            'label' => 'Issue re-opened',
+            'icon'  => 'rotate-left',
+            'tone'  => 'orange',
+        ])
+        ->and($assignee)->toMatchArray([
+            'type'        => 'assignee_changed',
+            'label'       => 'Assignee changed',
+            'description' => 'Assigned To changed from none to User Uuid.',
+            'icon'        => 'user-check',
+            'tone'        => 'indigo',
+        ])
+        ->and($category)->toMatchArray([
+            'type'        => 'issue_updated',
+            'label'       => 'Category changed',
+            'description' => 'Category changed from Damage to Delay.',
+            'icon'        => 'pen',
+            'tone'        => 'slate',
+        ]);
+});
+
+test('issue timeline change descriptions normalize uuid suffixes and blank values', function () {
+    $controller = new FleetOpsIssueControllerProbe();
+
+    expect($controller->callHelper('formatChangeDescription', 'driver_uuid', '', 'driver-uuid'))
+        ->toBe('Driver changed from none to Driver Uuid.')
+        ->and($controller->callHelper('formatChangeDescription', 'resolved_at', null, null))
+        ->toBe('Resolved At changed from none to none.');
+});
+
+test('removed document events fall back to a generic name', function () {
+    $probe = new FleetOpsIssueFileEventsProbe();
+    $issue = fleetopsTimelineIssue();
+
+    $named = fleetopsTimelineActivity(['uuid' => 'activity-file-1', 'event' => 'deleted']);
+    $named->setRawAttributes(array_merge($named->getAttributes(), [
+        'properties' => json_encode(['old' => ['original_filename' => 'inspection-report.pdf']]),
+    ]), true);
+
+    $unnamed = fleetopsTimelineActivity(['uuid' => 'activity-file-2', 'event' => 'deleted']);
+    $unnamed->setRawAttributes(array_merge($unnamed->getAttributes(), [
+        'properties' => json_encode(['old' => ['subject_uuid' => 'issue-uuid']]),
+    ]), true);
+
+    // Only deleted-file activities become removal events, and one with no
+    // recorded filename still reports something rather than an empty label
+    $probe->fileActivities = [$named, $unnamed, fleetopsTimelineActivity(['uuid' => 'activity-file-3', 'event' => 'updated'])];
+
+    $descriptions = $probe->callFileEvents($issue)
+        ->where('type', 'document_removed')
+        ->pluck('description')
+        ->all();
+
+    expect($descriptions)->toBe(['inspection-report.pdf', 'Document']);
+});

package/server/tests/LabelPdfRenderingTest.php

@@ -1,5 +1,48 @@
 <?php
 
+use Fleetbase\FleetOps\Support\LabelPdf;
+use Illuminate\Container\Container;
+
+class FleetOpsLabelPdfDompdfFake
+{
+    public array $options = [];
+
+    public function set_option(string $key, mixed $value): void
+    {
+        $this->options[$key] = $value;
+    }
+}
+
+class FleetOpsLabelPdfWrapperFake
+{
+    public array $loadedHtml = [];
+    public array $options    = [];
+
+    public FleetOpsLabelPdfDompdfFake $dompdf;
+
+    public function __construct()
+    {
+        $this->dompdf = new FleetOpsLabelPdfDompdfFake();
+    }
+
+    public function loadHTML(string $html, ?string $encoding = null): self
+    {
+        $this->loadedHtml[] = [$html, $encoding];
+
+        return $this;
+    }
+
+    public function setOptions(array $options): void
+    {
+        $this->options = $options;
+    }
+
+    public function getDomPDF(): FleetOpsLabelPdfDompdfFake
+    {
+        return $this->dompdf;
+    }
+}
+
 test('labels use the shared utf8 pdf renderer instead of arabic-only html rewriting', function () {
     $labelPdf = file_get_contents(dirname(__DIR__) . '/src/Support/LabelPdf.php');
     $order    = file_get_contents(dirname(__DIR__) . '/src/Models/Order.php');
@@ -21,3 +64,17 @@ test('labels use the shared utf8 pdf renderer instead of arabic-only html rewrit
         ->not->toContain('strtoupper($company->name)')
         ->and($utils)->not->toContain('fixArabicInHTML');
 });
+
+test('label pdf loads html with utf8 and applies renderer options', function () {
+    $wrapper = new FleetOpsLabelPdfWrapperFake();
+
+    Container::getInstance()->instance('dompdf.wrapper', $wrapper);
+
+    $pdf = LabelPdf::fromHtml('<strong>مرحبا</strong>');
+
+    expect($pdf)->toBe($wrapper)
+        ->and($wrapper->loadedHtml)->toBe([['<strong>مرحبا</strong>', 'UTF-8']])
+        ->and($wrapper->options)->toBe(LabelPdf::options())
+        ->and($wrapper->dompdf->options)->toBe(LabelPdf::dompdfOptions())
+        ->and(LabelPdf::options())->toBe(LabelPdf::dompdfOptions());
+});

package/server/tests/LalamoveIntegrationContractsTest.php

@@ -0,0 +1,167 @@
+<?php
+
+use Fleetbase\FleetOps\Exceptions\IntegratedVendorException;
+use Fleetbase\FleetOps\Integrations\Lalamove\Lalamove;
+use Fleetbase\FleetOps\Integrations\Lalamove\LalamoveDeliveryStop;
+use Fleetbase\FleetOps\Integrations\Lalamove\LalamoveMarket;
+use Fleetbase\FleetOps\Integrations\Lalamove\LalamoveServiceType;
+use Fleetbase\FleetOps\Models\ServiceQuote;
+use GuzzleHttp\Client;
+use GuzzleHttp\Handler\MockHandler;
+use GuzzleHttp\HandlerStack;
+use GuzzleHttp\Middleware;
+use GuzzleHttp\Psr7\Response;
+
+function fleetOpsLalamoveWithResponses(array $responses, array &$history = []): Lalamove
+{
+    $mock    = new MockHandler($responses);
+    $history = [];
+    $stack   = HandlerStack::create($mock);
+    $stack->push(Middleware::history($history));
+    $client = new Client([
+        'base_uri' => 'https://rest.sandbox.lalamove.com/v3/',
+        'handler'  => $stack,
+    ]);
+
+    $lalamove = new Lalamove('api-key', 'api-secret', true, 'SG');
+    $property = new ReflectionProperty($lalamove, 'client');
+    $property->setAccessible(true);
+    $property->setValue($lalamove, $client);
+
+    return $lalamove;
+}
+
+function fleetOpsLalamoveInvoke(object $target, string $method, array $arguments = []): mixed
+{
+    $reflection = new ReflectionMethod($target, $method);
+    $reflection->setAccessible(true);
+
+    return $reflection->invokeArgs($target, $arguments);
+}
+
+test('lalamove value objects resolve markets service types stops and cents', function () {
+    $market      = LalamoveMarket::find('sg');
+    $serviceType = LalamoveServiceType::find('motorcycle');
+    $stop        = new LalamoveDeliveryStop(1.25, 103.75, 'Depot');
+
+    expect($market)->toBeInstanceOf(LalamoveMarket::class)
+        ->and($market->getCode())->toBe('SG')
+        ->and($market->getLanguages())->toBe(['en_SG'])
+        ->and(LalamoveMarket::codes()->contains('SG'))->toBeTrue()
+        ->and($serviceType)->toBeInstanceOf(LalamoveServiceType::class)
+        ->and($serviceType->getKey())->toBe('MOTORCYCLE')
+        ->and($serviceType->length)->toBe('40cm')
+        ->and($stop->toArray())->toMatchArray([
+            'coordinates' => ['lat' => '1.25', 'lng' => '103.75'],
+            'address'     => 'Depot',
+        ])
+        ->and(json_decode($stop->toJson(), true))->toMatchArray(['address' => 'Depot'])
+        ->and(Lalamove::asCents('12.34'))->toBe(1234);
+});
+
+test('lalamove creates service quote models and line items from quotation payloads', function () {
+    session(['company' => 'company-uuid']);
+    $quotation = (object) [
+        'quotationId'    => 'quotation-1',
+        'priceBreakdown' => (object) [
+            'currency'     => 'SGD',
+            'total'        => '12.34',
+            'base'         => '10.00',
+            'extraMileage' => '1.23',
+            'vat'          => '1.11',
+        ],
+    ];
+
+    $wrapped = (object) ['data' => $quotation];
+    $quote   = Lalamove::serviceQuoteFromQuotation($wrapped, 'request-1');
+
+    expect($quote)->toBeInstanceOf(ServiceQuote::class)
+        ->and($quote->request_id)->toBe('request-1')
+        ->and($quote->company_uuid)->toBe('company-uuid')
+        ->and($quote->amount)->toBe('1234')
+        ->and($quote->currency)->toBe('SGD')
+        ->and($quote->items)->toHaveCount(3)
+        ->and($quote->items[0]->amount)->toBe('1000')
+        ->and($quote->items[0]->details)->toBe('Base fee')
+        ->and($quote->items[1]->code)->toBe('EXTRA_MILEAGE_FEE');
+})->skip('Standalone package model construction recurses through the container without the full app harness.');
+
+test('lalamove signs and sends quotation and order requests through guzzle', function () {
+    $history  = [];
+    $lalamove = fleetOpsLalamoveWithResponses([
+        new Response(200, [], json_encode(['data' => ['quotationId' => 'quotation-1']])),
+        new Response(200, [], json_encode(['data' => ['orderId' => 'order-1']])),
+    ], $history);
+
+    $quotation = $lalamove->getQuotations(
+        'MOTORCYCLE',
+        [1.25],
+        '2026-07-24 10:00:00',
+        ['HELP_BUY'],
+        true,
+        ['quantity' => '1'],
+        ['amount'   => '10.00']
+    );
+    $order = $lalamove->createOrder('quotation-1', ['name' => 'Sender', 'phone' => '+18004444444'], [
+        ['stopId' => 'dropoff', 'name' => 'Recipient', 'phone' => '+18005555555'],
+    ], true, true, ['fleetbase_order' => 'order_public']);
+
+    expect($quotation->data->quotationId)->toBe('quotation-1')
+        ->and($order->orderId)->toBe('order-1')
+        ->and($history)->toHaveCount(2);
+
+    $quotationRequest = $history[0]['request'];
+    $quotationBody    = json_decode((string) $quotationRequest->getBody(), true);
+
+    expect($quotationRequest->getMethod())->toBe('POST')
+        ->and((string) $quotationRequest->getUri())->toContain('/v3/quotations')
+        ->and($quotationRequest->getHeaderLine('Authorization'))->toStartWith('hmac api-key:')
+        ->and($quotationRequest->getHeaderLine('Market'))->toBe('SG')
+        ->and($quotationBody['data'])->toMatchArray([
+            'serviceType'      => 'MOTORCYCLE',
+            'language'         => 'en_SG',
+            'isRouteOptimized' => true,
+            'specialRequests'  => ['HELP_BUY'],
+            'item'             => ['quantity' => '1'],
+            'cashOnDelivery'   => ['amount' => '10.00'],
+        ]);
+    expect($quotationBody['data']['scheduleAt'])->toContain('2026-07-24');
+
+    $orderBody = json_decode((string) $history[1]['request']->getBody(), true);
+    expect($orderBody['data'])->toMatchArray([
+        'quotationId'           => 'quotation-1',
+        'sender'                => ['name' => 'Sender', 'phone' => '+18004444444'],
+        'isRecipientSMSEnabled' => true,
+        'isPODEnabled'          => true,
+        'metadata'              => ['fleetbase_order' => 'order_public'],
+    ]);
+});
+
+test('lalamove builds signatures urls options and throws vendor errors', function () {
+    $history  = [];
+    $lalamove = fleetOpsLalamoveWithResponses([
+        new Response(200, [], json_encode([
+            'errors' => [
+                ['id' => 'ERR_1', 'message' => 'Invalid order', 'detail' => 'Order missing'],
+            ],
+        ])),
+    ], $history);
+
+    $signature = fleetOpsLalamoveInvoke($lalamove, 'createSignature', [
+        '123456789',
+        'post',
+        'orders',
+        '{"data":[]}',
+    ]);
+
+    expect($signature)->toBe(hash_hmac('sha256', "123456789\r\nPOST\r\n/v3/orders\r\n\r\n{\"data\":[]}", 'api-secret'))
+        ->and(fleetOpsLalamoveInvoke($lalamove, 'buildRequestUrl', ['orders']))->toBe('https://rest.sandbox.lalamove.com/v3/orders')
+        ->and($lalamove->setRequestId('request-1'))->toBe($lalamove)
+        ->and($lalamove->setOptions(['priority' => true])->setOptions(['mode' => 'test'])->getOptions())->toBe([
+            'priority' => true,
+            'mode'     => 'test',
+        ]);
+
+    expect(fn () => $lalamove->cancelOrder('order-1'))
+        ->toThrow(IntegratedVendorException::class, 'Lalamove: ERR_1 Invalid order (Order missing)');
+});

package/server/tests/LiveOrderQueryTest.php

@@ -1,34 +1,155 @@
 <?php
 
 use Fleetbase\FleetOps\Support\LiveOrderQuery;
+use Illuminate\Database\Eloquent\Builder;
 
-test('active live order query uses the same active status rules as the map overlay', function () {
-    $query = LiveOrderQuery::make('company_test', [
+class FleetOpsLiveOrderQueryRecorder extends Builder
+{
+    public array $calls = [];
+
+    public function __construct()
+    {
+    }
+
+    public function where($column, $operator = null, $value = null, $boolean = 'and')
+    {
+        if (is_callable($column)) {
+            $nested = new self();
+            $column($nested);
+            $this->calls[] = ['whereNested', $nested->calls];
+
+            return $this;
+        }
+
+        $this->calls[] = ['where', $column, $operator, $value, $boolean];
+
+        return $this;
+    }
+
+    public function whereHas($relation, ?Closure $callback = null, $operator = '>=', $count = 1)
+    {
+        $nested = null;
+
+        if ($callback) {
+            $nested = new self();
+            $callback($nested);
+        }
+
+        $this->calls[] = ['whereHas', $relation, $nested?->calls, $operator, $count];
+
+        return $this;
+    }
+
+    public function orWhereHas($relation, ?Closure $callback = null, $operator = '>=', $count = 1)
+    {
+        $this->calls[] = ['orWhereHas', $relation, $operator, $count];
+
+        return $this;
+    }
+
+    public function whereNotIn($column, $values, $boolean = 'and')
+    {
+        $this->calls[] = ['whereNotIn', $column, $values, $boolean];
+
+        return $this;
+    }
+
+    public function whereNull($column, $boolean = 'and', $not = false)
+    {
+        $this->calls[] = ['whereNull', $column, $boolean, $not];
+
+        return $this;
+    }
+
+    public function applyDirectivesForPermissions(string $permission)
+    {
+        $this->calls[] = ['applyDirectivesForPermissions', $permission];
+
+        return $this;
+    }
+
+    public function with($relations, $callback = null)
+    {
+        $this->calls[] = ['with', $relations];
+
+        return $this;
+    }
+}
+
+class FleetOpsLiveOrderQueryProbe extends LiveOrderQuery
+{
+    public static ?FleetOpsLiveOrderQueryRecorder $recorder = null;
+
+    protected static function newOrderQuery(string $companyUuid): Builder
+    {
+        static::$recorder = new FleetOpsLiveOrderQueryRecorder();
+        static::$recorder->where('company_uuid', $companyUuid);
+
+        return static::$recorder;
+    }
+}
+
+afterEach(function () {
+    FleetOpsLiveOrderQueryProbe::$recorder = null;
+});
+
+test('live order query records base payload tracking permission and relation constraints', function () {
+    $query = FleetOpsLiveOrderQueryProbe::make('company-uuid', [
+        'exclude'           => ['order_abc1234'],
         'active'            => true,
-        'apply_permissions' => false,
+        'unassigned'        => true,
+        'with_relations'    => true,
+        'apply_permissions' => true,
     ]);
+    $calls = FleetOpsLiveOrderQueryProbe::$recorder->calls;
+
+    expect($query)->toBe(FleetOpsLiveOrderQueryProbe::$recorder)
+        ->and($calls)->toContain(['where', 'company_uuid', 'company-uuid', null, 'and'])
+        ->and($calls)->toContain(['whereNotIn', 'status', LiveOrderQuery::$baseExcludedStatuses, 'and'])
+        ->and($calls)->toContain(['whereNotIn', 'public_id', ['order_abc1234'], 'and'])
+        ->and($calls)->toContain(['applyDirectivesForPermissions', 'fleet-ops list order'])
+        ->and($calls)->toContain(['whereNotIn', 'status', LiveOrderQuery::$activeExcludedStatuses, 'and'])
+        ->and($calls)->toContain(['whereNull', 'driver_assigned_uuid', 'and', false])
+        ->and($calls)->toContain(['whereNull', 'deleted_at', 'and', false]);
 
-    $bindings = $query->getBindings();
+    expect(collect($calls)->where(0, 'whereHas')->pluck(1)->all())
+        ->toContain('payload', 'trackingNumber', 'trackingStatuses', 'driverAssigned');
 
-    expect($bindings)->toContain('company_test')
-        ->and($bindings)->toContain('created')
-        ->and($bindings)->toContain('pending')
-        ->and($bindings)->toContain('completed')
-        ->and($bindings)->toContain('canceled')
-        ->and($bindings)->toContain('expired')
-        ->and($bindings)->toContain('order_canceled');
+    $payload = collect($calls)->first(fn ($call) => $call[0] === 'whereHas' && $call[1] === 'payload');
+    expect($payload[2][0][0])->toBe('whereNested')
+        ->and($payload[2][0][1])->toContain(['whereHas', 'waypoints', null, '>=', 1])
+        ->and($payload[2][0][1])->toContain(['orWhereHas', 'pickup', '>=', 1])
+        ->and($payload[2][0][1])->toContain(['orWhereHas', 'dropoff', '>=', 1]);
+
+    $with          = collect($calls)->first(fn ($call) => $call[0] === 'with');
+    $withRelations = array_merge(array_values(array_filter($with[1], 'is_string')), array_keys(array_filter($with[1], 'is_callable')));
+
+    expect($withRelations)->toContain(
+        'payload.entities',
+        'payload.dropoff',
+        'payload.pickup',
+        'trackingNumber',
+        'trackingStatuses',
+        'driverAssigned',
+        'vehicleAssigned',
+        'customer',
+        'facilitator'
+    );
 });
 
-test('live order query requires renderable payload and tracking data', function () {
-    $query = LiveOrderQuery::make('company_test', [
-        'active'            => true,
+test('live order query can skip optional permission active unassigned and relation branches', function () {
+    FleetOpsLiveOrderQueryProbe::make('company-uuid', [
+        'active'            => false,
+        'unassigned'        => false,
+        'with_relations'    => false,
         'apply_permissions' => false,
     ]);
 
-    $sql = $query->toSql();
+    $calls = FleetOpsLiveOrderQueryProbe::$recorder->calls;
 
-    expect($sql)->toContain('exists')
-        ->and($sql)->toContain('payload')
-        ->and($sql)->toContain('tracking')
-        ->and($sql)->toContain('driver');
+    expect(collect($calls)->where(0, 'applyDirectivesForPermissions')->values())->toHaveCount(0)
+        ->and(collect($calls)->where(0, 'with')->values())->toHaveCount(0)
+        ->and(collect($calls)->where(0, 'whereHas')->pluck(1)->all())->not->toContain('driverAssigned')
+        ->and(collect($calls)->where(0, 'whereNull')->pluck(1)->all())->not->toContain('driver_assigned_uuid')
+        ->and(collect($calls)->where(0, 'whereNotIn')->values())->toHaveCount(1);
 });