Laravel Scout Array Driver for Testing

Laravel Scout Array Driver for Testing

This package adds array driver to Laravel Scout and provides custom PHPUnit assertions to make testing search related functionality easier.

Originally published at https://github.com

Installation

Install the package via Composer:

composer require sti3bas/laravel-scout-array-driver --dev

Set Scout driver to array in .env.testing file:

SCOUT_DRIVER=array 

or in phpunit.xml file:

<env name="SCOUT_DRIVER" value="array"/>

Usage

The Search facade provides the following methods and assertions:

assertContains($model, $callback = null)

Checks if model exists in the search index.

$user = factory(User::class)->create([
    'name' => 'Oliver',
]);

$user2 = User::withoutSyncingToSearch(function () { return factory(User::class)->create([ 'name' => 'John', ]); });

Search::assertContains($user) // passes ->assertContains($user2) // fails ->assertContains($user, function ($record) { // passes return $record['name'] === 'Oliver'; }) ->assertContains($user, function ($record) { // fails return $record['name'] === 'John'; }) ->assertContains($user2, function ($record) { // fails return $record['name'] === 'John'; });

assertNotContains($model, $callback = null)

Checks if model doesn't exist in the search index.

$user = factory(User::class)->create([
    'name' => 'Oliver',
]);

$user2 = User::withoutSyncingToSearch(function () { return factory(User::class)->create([ 'name' => 'John', ]); });

Search::assertNotContains($user) // fails ->assertNotContains($user2) // passes ->assertNotContains($user, function ($record) { // fails return $record['name'] === 'Oliver'; }) ->assertNotContains($user, function ($record) { // passes return $record['name'] === 'John'; }) ->assertNotContains($user2, function ($record) { // passes return $record['name'] === 'John'; });

assertContainsIn($index, $model, $callback = null)

Checks if model exists in custom search index.

$user = factory(User::class)->create([
    'name' => 'Oliver',
]);

Search::assertContainsIn('users', $user) // passes ->assertContainsIn('non_existing_index', $user) // fails ->assertContainsIn('users', $user, function ($record) { // passes return $record['name'] === 'Oliver'; }) ->assertContainsIn('users', $user, function ($record) { // fails return $record['name'] === 'John'; });

assertNotContainsIn($index, $model, $callback = null)

Checks if model doesn't exist in custom search index.

$user = factory(User::class)->create([
    'name' => 'Oliver',
]);

Search::assertNotContainsIn('users', $user) // fails ->assertNotContainsIn('non_existing_index', $user) // passes ->assertNotContainsIn('users', $user, function ($record) { // fails return $record['name'] === 'Oliver'; }) ->assertNotContainsIn('users', $user, function ($record) { // passes return $record['name'] === 'John'; });

assertEmpty()

Checks if all search indexes are empty.

Search::assertEmpty(); // passes

factory(User::class)->create();

Search::assertEmpty(); // fails

assertEmptyIn($index)

Checks if search index is empty.

Search::assertEmptyIn('users'); // passes

factory(User::class)->create();

Search::assertEmptyIn('users'); // fails

assertNotEmpty()

Checks if there is at least one record in any of search indexes.

Search::assertNotEmpty(); // fails

factory(User::class)->create();

Search::assertNotEmpty(); // passes

assertNotEmptyIn($index)

Checks if search index is not empty.

Search::assertNotEmptyIn('users'); // fails

factory(User::class)->create();

Search::assertNotEmptyIn('users'); // passes

assertSynced($model, $callback = null)

Checks if model was synced to search index. This assertion checks every record of the given model which was synced during the request.

$user = factory(User::class)->create([
    'name' => 'Peter',
]);

Search::assertSynced($user); // passes

$user->update(['name' => 'John']); $user->delete();

Search::assertContains($user) // fails ->assertSynced($user) // passes ->assertSynced($user, function ($record) { // passes return $record['name'] === 'Peter'; }) ->assertSynced($user, function ($record) { // passes return $record['name'] === 'John'; }) ->assertSynced($user, function ($record) { // fails return $record['name'] === 'Oliver'; });

assertNotSynced($model, $callback = null)

Checks if model wasn't synced to search index. This assertion checks every record of the given model which was synced during the request.

$user = factory(User::class)->create([
    'name' => 'Peter',
]);

Search::assertNotSynced($user); // fails

$user->update(['name' => 'John']); $user->delete();

Search::assertContains($user) // fails ->assertNotSynced($user); // fails

Search::assertNotSynced($user, function ($record) { // fails return $record['name'] === 'Peter'; }) ->assertNotSynced($user, function ($record) { // fails return $record['name'] === 'John'; }) ->assertNotSynced($user, function ($record) { // passes return $record['name'] === 'Oliver'; });

assertSyncedTo($model, $callback = null)

Checks if model was synced to custom search index. This assertion checks every record of the given model which was synced during the request.

$user = factory(User::class)->create([
    'name' => 'Peter',
]);

Search::assertSyncedTo('users', $user); // passes

$user->update(['name' => 'John']); $user->delete();

Search::assertContains($user) // fails ->assertSyncedTo('users', $user) // passes ->assertSyncedTo('users', $user, function ($record) { return $record['name'] === 'Peter'; // passes }) ->assertSyncedTo('users', $user, function ($record) { return $record['name'] === 'John'; // passes }) ->assertSyncedTo('non_existing_index', $user, function ($record) { return $record['name'] === 'John'; // fails });

assertNotSyncedTo($model, $callback = null)

Checks if model wasn't synced to custom search index. This assertion checks every record of the given model which was synced during the request.

$user = factory(User::class)->create([
    'name' => 'Peter',
]);

Search::assertNotSyncedTo('users', $user) // fails ->assertNotSyncedTo('not_existing_index', $user); // passes

$user->update(['name' => 'John']); $user->delete();

Search::assertContains($user) // fails ->assertNotSyncedTo('users', $user) // fails ->assertNotSyncedTo('users', $user, function ($record) { return $record['name'] === 'Peter'; // fails }) ->assertNotSyncedTo('users', $user, function ($record) { return $record['name'] === 'Oliver'; // passes });

assertSyncedTimes($model, $callback = null)

Checks if model was synced expected number of times. This assertion checks every record of the given model which was synced during the request.

$user = User::withoutSyncingToSearch(function () {
    return factory(User::class)->create([
        'name' => 'Peter',
    ]);
});

Search::assertSyncedTimes($user, 0) // passes ->assertSyncedTimes($user, 1); // fails

$user->searchable(); $user->update(['name' => 'John']); $user->delete();

Search::assertContains($user) // fails ->assertSyncedTimes($user, 2) // passes ->assertSyncedTimes($user, 1, function ($record) { return $record['name'] === 'Peter'; // passes }) ->assertSyncedTimes($user, 1, function ($record) { return $record['name'] === 'John'; // passes }) ->assertSyncedTimes($user, 1, function ($record) { return $record['name'] === 'Oliver'; // fails });

assertSyncedTimesTo($index, $model, $callback = null)

Checks if model was synced to custom search index expected number of times. This assertion checks every record of the given model which was synced during the request.

$user = User::withoutSyncingToSearch(function () {
    return factory(User::class)->create([
        'name' => 'Peter',
    ]);
});

Search::assertSyncedTimesTo('users', $user, 0) // passes ->assertSyncedTimesTo('non_existing_index', $user, 1); // fails

$user->searchable(); $user->update(['name' => 'John']); $user->delete();

Search::assertContains($user) // fails ->assertSyncedTimesTo('users', $user, 2) // passes ->assertSyncedTimesTo('users', $user, 1, function ($record) { return $record['name'] === 'Peter'; // passes }) ->assertSyncedTimesTo('non_existing_index', 1, function ($record) { return $record['name'] === 'John'; // fails });

assertNothingSynced()

Checks if nothing was synced to any of search indexes. This assertion checks every record which was synced during the request.

Search::assertNothingSynced(); // passes

factory(User::class)->create();

Search::assertNothingSynced(); // fails

assertNothingSyncedTo()

Checks if nothing was synced to custom search index. This assertion checks every record which was synced during the request.

Search::assertNothingSyncedTo('users'); // passes

factory(User::class)->create();

Search::assertNothingSyncedTo('users'); // fails

fakeRecord($model, $data, $merge = true, $index = null)

This method allows to fake search index record of the model. It will not affect assertions.

$user = factory(User::class)->create([
    'id' => 123,
    'name' => 'Peter',
    'email' => '[email protected]',
]);

Search::fakeRecord($user, [ 'name' => 'John', ]);

$record = User::search()->where('id', 123)->raw()['hits'][0];

$this->assertEquals('Peter', $record['name']); // fails $this->assertEquals('John', $record['name']); // passes $this->assertEquals('[email protected]', $record['email']); // passes

Search::fakeRecord($user, [ 'id' => 123, 'name' => 'John', ], false);

$record = User::search()->where('id', 123)->raw()['hits'][0];

$this->assertEquals('Peter', $record['name']); // fails $this->assertEquals('John', $record['name']); // passes $this->assertTrue(!isset($record['email'])); // passes

Thanks for reading

If you liked this post, share it with all of your programming buddies!

Follow me on Facebook | Twitter

Further reading

PHP with Laravel for beginners - Become a Master in Laravel

Projects in Laravel: Learn Laravel Building 10 Projects

Laravel for RESTful: Build Your RESTful API with Laravel

Fullstack Web Development With Laravel and Vue.js

Laravel 5.8 Tutorial for Beginners

Laravel 5.8 Ajax CRUD tutorial using Datatable JS

Laravel 5.8 Tutorial from Scratch for Beginners

Build RESTful API In Laravel 5.8 Example

Login with Google in Laravel 5.8 App using Socialite Package

Upgrading Laravel To 6.0 From 5.8

Laravel 6 Release New Features and Upgrade

laravel php testing web-development

Bootstrap 5 Complete Course with Examples

Bootstrap 5 Tutorial - Bootstrap 5 Crash Course for Beginners

Nest.JS Tutorial for Beginners

Hello Vue 3: A First Look at Vue 3 and the Composition API

Building a simple Applications with Vue 3

Deno Crash Course: Explore Deno and Create a full REST API with Deno

How to Build a Real-time Chat App with Deno and WebSockets

Convert HTML to Markdown Online

HTML entity encoder decoder Online

PHP Web Application Development Company

As a top **PHP Web Application Development Company in USA**[https://www.dataeximit.com/php-development-services/](https://www.dataeximit.com/php-development-services/ "https://www.dataeximit.com/php-development-services/"), we at Data EximIT have...

PHP Website Development

Skenix Infotech is a leading PHP Web Development Company that helps companies get results with industry best practices. Get affordable PHP Development Services.

Hire Dedicated PHP Developer

Looking to hire affordable yet experienced PHP developers? **[Hire Dedicated PHP Developer](https://hourlydeveloper.io/hire-dedicated-php-developer/ "Hire Dedicated PHP Developer")**, who can convert your idea to reality, within the stipulated...

How to Hire Laravel Developers and How Much Does It Cost.

Want to make the most out of the latest Laravel technology? Here is your guide on how to hire the best Laravel developer, and at the right price. 

Advantages of Hiring PHP Developer for your Website Project

PHP - Hypertext pre-processor, a scripting language used by many people in developing web pages, but most of us are unaware even of the full form. To train someone and make them learn this whole language is as difficult and time-consuming as it is...