sti3bas/laravel-scout-array-driver

Laravel Scout 的数组驱动

维护者

详情

github.com/Sti3bas/laravel-scout-array-driver

源代码

问题

安装: 800,926

依赖者: 2

建议者: 0

安全性: 0

星星: 89

关注者: 1

分支: 8

开放问题: 1

v4.1 2024-09-23 11:32 UTC

Requires

Requires (Dev)

MIT 774ec432217fdbe1d8e21fb226af5292555dc938

  • Laurynas Geigalas <sti3bas.woop@gmail.com>

testingarraydriverlaravelscout

This package is auto-updated.

Last update: 2024-09-23 11:36:41 UTC

README

此包为 Laravel Scout 添加了一个 array 驱动，并提供了自定义的 PHPUnit 断言，以简化搜索相关功能的测试。

内容

安装

通过 Composer 安装此包

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

在 .env.testing 文件中设置 Scout 驱动为 array

SCOUT_DRIVER=array

或在 phpunit.xml 文件中

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

使用

Search 门面提供了以下方法和断言

assertContains($model, $callback = null)

检查模型是否存在于搜索索引中。

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

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

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

assertNotContains($model, $callback = null)

检查模型是否不存在于搜索索引中。

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

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

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

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

检查模型是否存在于自定义搜索索引中。

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

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

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

检查模型是否不存在于自定义搜索索引中。

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

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

assertEmpty()

检查所有搜索索引是否为空。

Search::assertEmpty(); // ✅

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

Search::assertEmpty(); // ❌

assertEmptyIn($index)

检查搜索索引是否为空。

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

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

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

assertNotEmpty()

检查至少有一个记录在任何一个搜索索引中。

Search::assertNotEmpty(); // ❌

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

Search::assertNotEmpty(); // ✅

assertNotEmptyIn($index)

检查搜索索引是否不为空。

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

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

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

assertCount($count)

检查至少有一个记录在任何一个搜索索引中。

Search::assertCount(1); // ❌

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

Search::assertCount(1); // ✅

assertCountIn($index)

检查搜索索引是否不为空。

Search::assertNotEmptyIn('users', 1); // ❌

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

Search::assertNotEmptyIn('users', 1); // ✅

assertSynced($model, $callback = null)

检查模型是否已同步到搜索索引。此断言检查在请求期间同步的给定模型的所有记录。

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

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

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

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

assertNotSynced($model, $callback = null)

检查模型是否未同步到搜索索引。此断言检查在请求期间同步的给定模型的所有记录。

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

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

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

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

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

assertSyncedTo($model, $callback = null)

检查模型是否已同步到自定义搜索索引。此断言检查在请求期间同步的给定模型的所有记录。

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

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

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

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

assertNotSyncedTo($model, $callback = null)

检查模型是否未同步到自定义搜索索引。此断言检查在请求期间同步的给定模型的所有记录。

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

Search::assertNotSyncedTo('users', $user) // ❌
    ->assertNotSyncedTo('not_existing_index', $user); // ✅

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

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

assertSyncedTimes($model, $callback = null)

检查模型是否已同步到预期次数。此断言检查在请求期间同步的给定模型的所有记录。

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

Search::assertSyncedTimes($user, 0) // ✅
    ->assertSyncedTimes($user, 1); // ❌

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

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

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

检查模型是否已同步到自定义搜索索引到预期次数。此断言检查在请求期间同步的给定模型的所有记录。

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

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

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

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

assertNothingSynced()

检查没有任何内容同步到任何搜索索引中。此断言检查在请求期间同步的所有记录。

Search::assertNothingSynced(); // ✅

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

Search::assertNothingSynced(); // ❌

assertNothingSyncedTo()

检查没有内容同步到自定义搜索索引。此断言检查在请求期间同步的所有记录。

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

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

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

assertIndexExists($index)

检查搜索索引是否存在。

$manager = $this->app->make(EngineManager::class);

$engine = $manager->engine();

Search::assertIndexExists('test'); // ❌

$engine->createIndex('test');

Search::assertIndexExists('test'); // ✅

assertIndexNotExists($index)

检查搜索索引不存在。

$manager = $this->app->make(EngineManager::class);

$engine = $manager->engine();

Search::assertIndexNotExists('test'); // ✅

$engine->createIndex('test');

Search::assertIndexNotExists('test'); // ❌

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

此方法允许伪造模型的搜索索引记录。它不会影响断言。

$user = User::factory()->create([
    'id' => 123,
    'name' => 'Peter',
    'email' => 'peter@example.com',
]);

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

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

$this->assertEquals('Peter', $record['name']); // ❌
$this->assertEquals('John', $record['name']); // ✅
$this->assertEquals('peter@example.com', $record['email']); // ✅

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

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

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

许可

The MIT License (MIT). 请参阅 许可文件 以获取更多信息。