@fleetbase/fleetops-engine 0.6.58 → 0.6.60

package/server/tests/Feature/Http/Api/DriverControllerHelpersTest.php

@@ -0,0 +1,240 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Controllers\Api\v1\DriverController;
+use Fleetbase\FleetOps\Http\Resources\v1\DeletedResource;
+use Fleetbase\FleetOps\Http\Resources\v1\Driver as DriverResource;
+use Fleetbase\FleetOps\Jobs\SimulateDrivingRoute;
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Models\Payload;
+use Fleetbase\LaravelMysqlSpatial\Types\Point;
+use Fleetbase\TestSupport\DispatchRecorder;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+/**
+ * Exercises the real bodies of the API DriverController's protected helper
+ * methods and the self-contained route-simulation methods. The existing
+ * ApiDriverControllerContractsTest overrides these helpers on its probe, which
+ * leaves their real one-line implementations uncovered; here we invoke the
+ * genuine parent implementations through reflection so the underlying facade
+ * and resource calls execute.
+ */
+class FleetOpsApiDriverHelpersProbe extends DriverController
+{
+    public function callProtected(string $method, array $arguments = []): mixed
+    {
+        $reflection = new ReflectionMethod(DriverController::class, $method);
+        $reflection->setAccessible(true);
+
+        return $reflection->invoke($this, ...$arguments);
+    }
+}
+
+class FleetOpsApiDriverHelpersDriverFake extends Driver
+{
+    protected $guarded = [];
+    public $exists     = true;
+
+    public function __construct(array $attributes = [])
+    {
+        parent::__construct();
+        $this->setRawAttributes($attributes, true);
+    }
+}
+
+class FleetOpsApiDriverHelpersPlaceFake extends Fleetbase\FleetOps\Models\Place
+{
+    protected $guarded    = [];
+    public $exists        = true;
+    public ?Point $point  = null;
+
+    public static function at(Point $point): self
+    {
+        $place        = new self();
+        $place->point = $point;
+        $place->setRawAttributes(['uuid' => 'place-uuid'], true);
+
+        return $place;
+    }
+
+    public function getAttribute($key)
+    {
+        if ($key === 'location') {
+            return $this->point;
+        }
+
+        return parent::getAttribute($key);
+    }
+}
+
+class FleetOpsApiDriverHelpersPayloadFake extends Payload
+{
+    protected $guarded                               = [];
+    public $exists                                   = true;
+    public ?Fleetbase\FleetOps\Models\Place $pickup  = null;
+    public ?Fleetbase\FleetOps\Models\Place $dropoff = null;
+
+    public function __construct()
+    {
+        parent::__construct();
+        $this->setRawAttributes(['uuid' => 'payload-uuid'], true);
+    }
+
+    public function getPickupOrFirstWaypoint(): ?Fleetbase\FleetOps\Models\Place
+    {
+        return $this->pickup;
+    }
+
+    public function getDropoffOrLastWaypoint(): ?Fleetbase\FleetOps\Models\Place
+    {
+        return $this->dropoff;
+    }
+}
+
+class FleetOpsApiDriverHelpersOrderFake extends Order
+{
+    protected $guarded = [];
+    public $exists     = true;
+
+    public function __construct(array $attributes = [])
+    {
+        parent::__construct();
+        $this->setRawAttributes(array_merge(['uuid' => 'order-uuid'], $attributes), true);
+    }
+}
+
+function fleetopsApiDriverHelpersProbe(): FleetOpsApiDriverHelpersProbe
+{
+    return new FleetOpsApiDriverHelpersProbe();
+}
+
+function fleetopsApiDriverHelpersSeedRoute(Point $start, Point $end, array $route): void
+{
+    $key = 'getRoute:' . md5($start . $end . serialize([]));
+    Illuminate\Support\Facades\Cache::put($key, $route, 3600);
+}
+
+/*
+|--------------------------------------------------------------------------
+| Protected helper methods
+|--------------------------------------------------------------------------
+*/
+
+test('session company helper reads the company from the session store', function () {
+    session(['company' => 'company-abc']);
+
+    expect(fleetopsApiDriverHelpersProbe()->callProtected('sessionCompany'))->toBe('company-abc');
+});
+
+test('point from coordinates helper builds a spatial point', function () {
+    $point = fleetopsApiDriverHelpersProbe()->callProtected('pointFromCoordinates', [[
+        'latitude'  => 1.3521,
+        'longitude' => 103.8198,
+    ]]);
+
+    expect($point)->toBeInstanceOf(Point::class)
+        ->and($point->getLat())->toBe(1.3521)
+        ->and($point->getLng())->toBe(103.8198);
+});
+
+test('json response helper returns a json response with the supplied status', function () {
+    $response = fleetopsApiDriverHelpersProbe()->callProtected('jsonResponse', [['ok' => true], 201]);
+
+    expect($response)->toBeInstanceOf(JsonResponse::class)
+        ->and($response->getStatusCode())->toBe(201)
+        ->and($response->getData(true))->toBe(['ok' => true]);
+});
+
+test('driver resource helpers wrap drivers in their api resources', function () {
+    $driver = new FleetOpsApiDriverHelpersDriverFake(['uuid' => 'driver-uuid', 'public_id' => 'driver_test']);
+    $probe  = fleetopsApiDriverHelpersProbe();
+
+    expect($probe->callProtected('driverResource', [$driver]))->toBeInstanceOf(DriverResource::class)
+        ->and($probe->callProtected('deletedDriverResource', [$driver]))->toBeInstanceOf(DeletedResource::class)
+        ->and($probe->callProtected('driverResourceCollection', [[$driver]]))
+        ->toBeInstanceOf(Illuminate\Http\Resources\Json\ResourceCollection::class);
+});
+
+test('apply user info helper delegates to the user model helper', function () {
+    $request = Request::create('/fleet-ops/drivers', 'POST');
+
+    $result = fleetopsApiDriverHelpersProbe()->callProtected('applyUserInfoFromRequest', [$request, ['name' => 'Ada']]);
+
+    expect($result)->toBeArray()
+        ->and($result['name'])->toBe('Ada');
+});
+
+/*
+|--------------------------------------------------------------------------
+| Route simulation
+|--------------------------------------------------------------------------
+*/
+
+test('simulate driving for route returns the osrm payload when no route is found', function () {
+    DispatchRecorder::$dispatched = [];
+    $driver                       = new FleetOpsApiDriverHelpersDriverFake(['uuid' => 'driver-uuid']);
+    $start                        = new Point(1.0, 2.0);
+    $end                          = new Point(3.0, 4.0);
+    fleetopsApiDriverHelpersSeedRoute($start, $end, ['code' => 'NoRoute']);
+
+    $response = fleetopsApiDriverHelpersProbe()->simulateDrivingForRoute($driver, $start, $end);
+
+    expect($response)->toBeInstanceOf(JsonResponse::class)
+        ->and($response->getData(true))->toBe(['code' => 'NoRoute'])
+        ->and(DispatchRecorder::$dispatched)->toBe([]);
+});
+
+test('simulate driving for route dispatches the simulation job on a successful route', function () {
+    DispatchRecorder::$dispatched = [];
+    $driver                       = new FleetOpsApiDriverHelpersDriverFake(['uuid' => 'driver-uuid']);
+    $start                        = new Point(1.0, 2.0);
+    $end                          = new Point(3.0, 4.0);
+    fleetopsApiDriverHelpersSeedRoute($start, $end, ['code' => 'Ok', 'routes' => [['geometry' => 'ojfGx_zsAvBcH']]]);
+
+    $response = fleetopsApiDriverHelpersProbe()->simulateDrivingForRoute($driver, $start, $end);
+
+    expect($response)->toBeInstanceOf(JsonResponse::class)
+        ->and($response->getData(true)['code'])->toBe('Ok')
+        ->and(DispatchRecorder::$dispatched)->toHaveCount(1)
+        ->and(DispatchRecorder::$dispatched[0]['job'])->toBe(SimulateDrivingRoute::class);
+});
+
+test('simulate driving for order computes headings and dispatches the simulation job', function () {
+    DispatchRecorder::$dispatched = [];
+    $driver                       = new FleetOpsApiDriverHelpersDriverFake(['uuid' => 'driver-uuid']);
+    $payload                      = new FleetOpsApiDriverHelpersPayloadFake();
+    $payload->pickup              = FleetOpsApiDriverHelpersPlaceFake::at(new Point(1.0, 2.0));
+    $payload->dropoff             = FleetOpsApiDriverHelpersPlaceFake::at(new Point(3.0, 4.0));
+    $order                        = new FleetOpsApiDriverHelpersOrderFake();
+    $order->setRelation('payload', $payload);
+    $start = Fleetbase\FleetOps\Support\Utils::getPointFromMixed($payload->pickup);
+    $end   = Fleetbase\FleetOps\Support\Utils::getPointFromMixed($payload->dropoff);
+    fleetopsApiDriverHelpersSeedRoute($start, $end, ['code' => 'Ok', 'routes' => [['geometry' => 'ojfGx_zsAvBcH']]]);
+
+    $response = fleetopsApiDriverHelpersProbe()->simulateDrivingForOrder($driver, $order);
+
+    expect($response)->toBeInstanceOf(JsonResponse::class)
+        ->and($response->getData(true)['code'])->toBe('Ok')
+        ->and(DispatchRecorder::$dispatched)->toHaveCount(1)
+        ->and(DispatchRecorder::$dispatched[0]['job'])->toBe(SimulateDrivingRoute::class);
+});
+
+test('simulate driving for order returns the osrm payload when no route is found', function () {
+    DispatchRecorder::$dispatched = [];
+    $driver                       = new FleetOpsApiDriverHelpersDriverFake(['uuid' => 'driver-uuid']);
+    $payload                      = new FleetOpsApiDriverHelpersPayloadFake();
+    $payload->pickup              = FleetOpsApiDriverHelpersPlaceFake::at(new Point(5.0, 6.0));
+    $payload->dropoff             = FleetOpsApiDriverHelpersPlaceFake::at(new Point(7.0, 8.0));
+    $order                        = new FleetOpsApiDriverHelpersOrderFake();
+    $order->setRelation('payload', $payload);
+    $start = Fleetbase\FleetOps\Support\Utils::getPointFromMixed($payload->pickup);
+    $end   = Fleetbase\FleetOps\Support\Utils::getPointFromMixed($payload->dropoff);
+    fleetopsApiDriverHelpersSeedRoute($start, $end, ['code' => 'NoRoute']);
+
+    $response = fleetopsApiDriverHelpersProbe()->simulateDrivingForOrder($driver, $order);
+
+    expect($response)->toBeInstanceOf(JsonResponse::class)
+        ->and($response->getData(true))->toBe(['code' => 'NoRoute'])
+        ->and(DispatchRecorder::$dispatched)->toBe([]);
+});

package/server/tests/Feature/Http/Api/DriverControllerLookupTest.php

@@ -0,0 +1,186 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Controllers\Api\v1\DriverController;
+use Fleetbase\FleetOps\Http\Requests\DriverSimulationRequest;
+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 driver-lookup and organization endpoints of the API
+ * DriverController through an in-memory SQLite fixture. These paths were
+ * previously unreachable because their not-found branches return
+ * response()->apiError(...)/response()->json(..., 404); the bootstrap now
+ * provides those shims so the real controller error handling executes.
+ */
+class FleetOpsApiDriverLookupDatabase
+{
+    public function __construct(public SQLiteConnection $connection)
+    {
+    }
+
+    public function connection($name = null): SQLiteConnection
+    {
+        return $this->connection;
+    }
+
+    public function __call($method, $arguments)
+    {
+        return $this->connection->{$method}(...$arguments);
+    }
+}
+
+function fleetopsApiDriverLookupBoot(): 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 FleetOpsApiDriverLookupDatabase($connection));
+
+    $schema = $connection->getSchemaBuilder();
+    $schema->create('users', function ($table) {
+        $table->increments('id');
+        $table->string('uuid')->nullable();
+        $table->string('company_uuid')->nullable();
+        $table->timestamp('deleted_at')->nullable();
+    });
+    $schema->create('drivers', function ($table) {
+        $table->increments('id');
+        $table->string('uuid')->nullable();
+        $table->string('public_id')->nullable();
+        $table->string('internal_id')->nullable();
+        $table->string('company_uuid')->nullable();
+        $table->string('user_uuid')->nullable();
+        $table->timestamp('deleted_at')->nullable();
+    });
+    $schema->create('orders', function ($table) {
+        $table->increments('id');
+        $table->string('uuid')->nullable();
+        $table->string('public_id')->nullable();
+        $table->string('internal_id')->nullable();
+        $table->timestamp('deleted_at')->nullable();
+    });
+    $schema->create('companies', function ($table) {
+        $table->increments('id');
+        $table->string('uuid')->nullable();
+        $table->string('public_id')->nullable();
+        $table->timestamp('deleted_at')->nullable();
+    });
+
+    return $connection;
+}
+
+function fleetopsApiDriverLookupSeedDriver(SQLiteConnection $connection): void
+{
+    $connection->table('users')->insert(['uuid' => 'user-uuid', 'company_uuid' => 'company-uuid']);
+    $connection->table('drivers')->insert([
+        'uuid'         => 'driver-uuid',
+        'public_id'    => 'driver_test',
+        'company_uuid' => 'company-uuid',
+        'user_uuid'    => 'user-uuid',
+    ]);
+    $connection->table('companies')->insert(['uuid' => 'company-uuid', 'public_id' => 'company_test']);
+}
+
+test('current organization endpoint returns a 404 error when the driver is missing', function () {
+    fleetopsApiDriverLookupBoot();
+
+    $response = (new DriverController())->currentOrganization('missing', Request::create('/x', 'GET'));
+
+    expect($response)->toBeInstanceOf(JsonResponse::class)
+        ->and($response->getStatusCode())->toBe(404)
+        ->and($response->getData(true))->toBe(['error' => 'Driver resource not found.']);
+});
+
+test('list organizations endpoint returns a 404 error when the driver is missing', function () {
+    fleetopsApiDriverLookupBoot();
+
+    $response = (new DriverController())->listOrganizations('missing', Request::create('/x', 'GET'));
+
+    expect($response)->toBeInstanceOf(JsonResponse::class)
+        ->and($response->getStatusCode())->toBe(404)
+        ->and($response->getData(true))->toBe(['error' => 'Driver resource not found.']);
+});
+
+test('simulate endpoint returns a 404 error when the driver is missing', function () {
+    fleetopsApiDriverLookupBoot();
+
+    $request  = DriverSimulationRequest::create('/x', 'POST', ['start' => null, 'end' => null]);
+    $response = (new DriverController())->simulate('missing', $request);
+
+    expect($response)->toBeInstanceOf(JsonResponse::class)
+        ->and($response->getStatusCode())->toBe(404)
+        ->and($response->getData(true))->toBe(['error' => 'Driver resource not found.']);
+});
+
+test('simulate endpoint returns a 404 error when the referenced order is missing', function () {
+    $connection = fleetopsApiDriverLookupBoot();
+    fleetopsApiDriverLookupSeedDriver($connection);
+
+    $request  = DriverSimulationRequest::create('/x', 'POST', ['order' => 'order_missing']);
+    $response = (new DriverController())->simulate('driver_test', $request);
+
+    expect($response)->toBeInstanceOf(JsonResponse::class)
+        ->and($response->getStatusCode())->toBe(404)
+        ->and($response->getData(true))->toBe(['error' => 'Order resource not found.']);
+});
+
+test('driver company resolver reads the company from the matching driver profile', function () {
+    $connection = fleetopsApiDriverLookupBoot();
+    fleetopsApiDriverLookupSeedDriver($connection);
+
+    $user = new Fleetbase\Models\User();
+    $user->setRawAttributes(['uuid' => 'user-uuid', 'company_uuid' => 'company-uuid'], true);
+
+    $reflection = new ReflectionMethod(DriverController::class, 'getDriverCompanyFromUser');
+    $reflection->setAccessible(true);
+    $company = $reflection->invoke(null, $user);
+
+    expect($company)->toBeInstanceOf(Fleetbase\Models\Company::class)
+        ->and($company->uuid)->toBe('company-uuid');
+});
+
+test('simulate routes drivers to order and route simulations', function () {
+    $connection = fleetopsApiDriverLookupBoot();
+    fleetopsApiDriverLookupSeedDriver($connection);
+    $connection->table('orders')->insert(['uuid' => 'order-uuid', 'public_id' => 'order_test']);
+
+    $probe = new class extends DriverController {
+        public array $calls = [];
+
+        public function simulateDrivingForOrder(Fleetbase\FleetOps\Models\Driver $driver, Fleetbase\FleetOps\Models\Order $order)
+        {
+            $this->calls[] = ['order', $order->public_id];
+
+            return 'order-simulation';
+        }
+
+        public function simulateDrivingForRoute(Fleetbase\FleetOps\Models\Driver $driver, $start, $end)
+        {
+            $this->calls[] = ['route', $start, $end];
+
+            return 'route-simulation';
+        }
+    };
+
+    // Orders resolve and delegate into the order simulation
+    $ordered = $probe->simulate('driver_test', DriverSimulationRequest::create('/x', 'POST', ['order' => 'order_test']));
+    expect($ordered)->toBe('order-simulation')
+        ->and($probe->calls[0])->toBe(['order', 'order_test']);
+
+    // Without an order the start/end pair drives the route simulation
+    $routed = $probe->simulate('driver_test', DriverSimulationRequest::create('/x', 'POST', [
+        'start' => '1.30,103.80',
+        'end'   => '1.35,103.85',
+    ]));
+    expect($routed)->toBe('route-simulation')
+        ->and($probe->calls[1])->toBe(['route', '1.30,103.80', '1.35,103.85']);
+
+    // Unknown orders report the order-not-found error
+    $missingOrder = $probe->simulate('driver_test', DriverSimulationRequest::create('/x', 'POST', ['order' => 'order_missing']));
+    expect($missingOrder->getStatusCode())->toBe(404)
+        ->and($missingOrder->getData(true))->toBe(['error' => 'Order resource not found.']);
+});

package/server/tests/Feature/Http/Api/DriverControllerOrganizationsTest.php

@@ -0,0 +1,112 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Controllers\Api\v1\DriverController;
+use Fleetbase\Http\Resources\Organization;
+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 API DriverController organization endpoints against SQLite:
+ * resolving the driver's current organization through the company session
+ * fallback chain, the missing-user and missing-company error branches, and
+ * listing all organizations the driver's user account belongs to.
+ */
+const FLEETOPS_DRIVER_ORG_USER      = '11111111-1111-4111-8111-111111111111';
+const FLEETOPS_DRIVER_ORG_COMPANY_1 = '22222222-2222-4222-8222-222222222222';
+const FLEETOPS_DRIVER_ORG_COMPANY_2 = '33333333-3333-4333-8333-333333333333';
+
+function fleetopsDriverOrgBoot(): 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();
+    app()->instance('db.schema', $schema);
+    $tables = [
+        'users'         => ['uuid', 'public_id', 'company_uuid', 'name', 'email', 'phone', 'status', 'type'],
+        'drivers'       => ['uuid', 'public_id', 'internal_id', 'company_uuid', 'user_uuid', 'vehicle_uuid', 'status', 'online', 'location'],
+        'companies'     => ['uuid', 'public_id', 'name', 'options', 'status', 'owner_uuid'],
+        'company_users' => ['uuid', 'company_uuid', 'user_uuid', 'status'],
+    ];
+    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' => FLEETOPS_DRIVER_ORG_COMPANY_1]);
+
+    $connection->table('users')->insert(['uuid' => FLEETOPS_DRIVER_ORG_USER, 'company_uuid' => FLEETOPS_DRIVER_ORG_COMPANY_1, 'name' => 'Driver One']);
+    $connection->table('companies')->insert([
+        ['uuid' => FLEETOPS_DRIVER_ORG_COMPANY_1, 'public_id' => 'company_one', 'name' => 'One'],
+        ['uuid' => FLEETOPS_DRIVER_ORG_COMPANY_2, 'public_id' => 'company_two', 'name' => 'Two'],
+    ]);
+    $connection->table('company_users')->insert([
+        ['uuid' => 'cu-1', 'company_uuid' => FLEETOPS_DRIVER_ORG_COMPANY_1, 'user_uuid' => FLEETOPS_DRIVER_ORG_USER],
+        ['uuid' => 'cu-2', 'company_uuid' => FLEETOPS_DRIVER_ORG_COMPANY_2, 'user_uuid' => FLEETOPS_DRIVER_ORG_USER],
+    ]);
+    $connection->table('drivers')->insert([
+        ['uuid' => 'driver-1', 'public_id' => 'driver_one', 'company_uuid' => FLEETOPS_DRIVER_ORG_COMPANY_1, 'user_uuid' => FLEETOPS_DRIVER_ORG_USER],
+        ['uuid' => 'driver-2', 'public_id' => 'driver_two', 'company_uuid' => FLEETOPS_DRIVER_ORG_COMPANY_2, 'user_uuid' => FLEETOPS_DRIVER_ORG_USER],
+    ]);
+
+    return $connection;
+}
+
+test('current organization resolves the company for the driver user', function () {
+    fleetopsDriverOrgBoot();
+
+    $organization = (new DriverController())->currentOrganization('driver_one', Request::create('/x', 'GET'));
+
+    expect($organization)->toBeInstanceOf(Organization::class)
+        ->and($organization->uuid)->toBe(FLEETOPS_DRIVER_ORG_COMPANY_1);
+});
+
+test('current organization errors when the company cannot be resolved', function () {
+    $connection = fleetopsDriverOrgBoot();
+
+    // User whose company cannot be resolved through the session fallback
+    // chain: non-uuid company reference and no company_users memberships.
+    // (A missing user row is unreachable here — the driver global scope
+    // already excludes drivers without an existing user.)
+    $connection->table('users')->where('uuid', FLEETOPS_DRIVER_ORG_USER)->update(['company_uuid' => 'not-a-uuid']);
+    $connection->table('company_users')->delete();
+    $noCompany = (new DriverController())->currentOrganization('driver_one', Request::create('/x', 'GET'));
+    expect($noCompany)->toBeInstanceOf(JsonResponse::class)
+        ->and($noCompany->getData(true)['error'])->toContain('No company found');
+});
+
+test('list organizations returns every company the driver user belongs to', function () {
+    fleetopsDriverOrgBoot();
+
+    $organizations = (new DriverController())->listOrganizations('driver_one', Request::create('/x', 'GET'));
+
+    expect($organizations->count())->toBe(2)
+        ->and($organizations->collection->pluck('public_id')->all())->toContain('company_one', 'company_two');
+});