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

Advantages of Hiring PHP Developer for your Website Project

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...

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 to learn the language yourself. That’s why PHP developers are there to make your life easy. This article will give us the advantages and requirements of Hire PHP Developer for our very own website project.

First of all, let us understand the value the right developer brings to the project and why it is important for your business.

A website is a major component of any company/business and is very important for its face value, the way it represents the company on the internet is critical for any business to succeed. This is the reason why companies are looking for PHP developers who can develop their webpage.

If you're planning to do an online business, your PHP programmer will be the first person to transfer your thinking onto the webpage. You should, therefore, employ developers from PHP to make your hypothetical idea a reality.

With this software programming language, PHP developers all-around can easily build website frameworks, web content management systems, web template systems, and various other web-based designs.

Some of the reasons why we need to outsource these developers are:

Not everyone is the best in each field, all of us have our specific skills and talents hence, PHP developers are also the best at what they do. The time and money spent on the training of the in house employees would be saved if the professional PHP developers are hired. Instead of multitasking, if the employees were to focus on what they’re good at it would increase productivity too.

The PHP developers would be much more professional than the in-house workers. It would lead to the seriousness of work. Hence, on-time delivery is guaranteed with hired PHP developers.

In addition to these benefits, you would also be able to track your project through every stage in constant communication with your online team. These advantages make it incredibly popular and smart to hire a PHP developer.

The PHP developers have in-depth knowledge of PHP, HTML and various frameworks in terms of technical capabilities. Hiring PHP developers are advised to give your website a professional look based on PHP.

Much of web success depends on the involvement of social media. The developer can add to your social networking pages a feature that explicitly redirects visitors. In addition, SEO experts also suggest better connections to the website's social network.

Just like a tailor stitches our dresses according to our preferences and is ready to make last-minute changes. A PHP developer will also be available at the nick of your call to make the website just the way you want it to be and have a customized solution for every problem.

Read also: Why & How to Hire Dedicated PHP Developer

At some point in your business, you’re going to have problems regarding your webpage due to the rapidly changing technology, instead of struggling with ideas like these and not being able to come up with an appropriate solution a PHP web developer could help us with our problems just like any technician would help us with the problems we face in our offices or any architect would help us with designing the structure of a building or any interior designer would help us with setting up our home. The PHP development company are hubs of workers who would help us overcome these problems and are always there.

Source by

Hire PHP Developer and Web Developer for your Online Business

Hire PHP Developer and Web Developer for your Online Business

PHP is widely used open-source scripting language it helps in making dynamically easy your websites and web application. Mobiweb Technology is your best technical partner and offering you solution for any kind of website and application...

PHP is widely used open-source scripting language it helps in making dynamically easy your websites and web application. Mobiweb Technology is your best technical partner and offering you solution for any kind of website and application development. To hire PHP developer and web developer at affordable prices contact Mobiweb Technology via [email protected]

Laravel Framework Development Services | Laravel Web Development

CMARIX is leading Laravel Web application Development Service Provider with the track record of implementing diverse high-performance Laravel web applications with skilled Laravel developer team for clients across the globe<a href="https://www.cmarix.com/laravel-framework-development-services.html?utm_source=SB" target="_blank">.Continue</a>

CMARIX is leading Laravel Web application Development Service Provider with the track record of implementing diverse high-performance Laravel web applications with skilled Laravel developer team for clients across the globe.Continue