Add search response fake helpers

Author: stevebauman

src/Documents/Document.php

@@ -18,6 +18,16 @@ public function __construct(
         protected array $source,
     ) {}
 
+    /**
+     * Create a fake document instance.
+     *
+     * @param  array<string, mixed>  $source
+     */
+    public static function fake(string $id = '1', array $source = []): static
+    {
+        return new static($id, $source);
+    }
+
     /**
      * Get the document identifier.
      */

src/Search/Hit.php

@@ -18,6 +18,35 @@ public function __construct(
         protected array $hit,
     ) {}
 
+    /**
+     * Create a fake search hit instance.
+     *
+     * @param  Document|array<string, mixed>  $source
+     * @param  array<string, mixed>  $attributes
+     */
+    public static function fake(Document|array $source = [], string $index = 'test', string $id = '1', ?float $score = null, array $attributes = []): static
+    {
+        if ($source instanceof Document) {
+            $id = $source->id();
+            $source = $source->source();
+        }
+
+        if (array_key_exists('_source', $source) || array_key_exists('_id', $source)) {
+            return new static(array_merge([
+                '_index' => $index,
+                '_id' => $id,
+                '_score' => $score,
+            ], $source, $attributes));
+        }
+
+        return new static(array_merge([
+            '_index' => $index,
+            '_id' => $id,
+            '_score' => $score,
+            '_source' => $source,
+        ], $attributes));
+    }
+
     /**
      * Get the index name for the hit.
      */

src/Search/SearchResponse.php

@@ -2,6 +2,8 @@
 
 namespace DirectoryTree\OpenSearchAdapter\Search;
 
+use DirectoryTree\OpenSearchAdapter\Documents\Document;
+
 /**
  * @see https://docs.opensearch.org/latest/api-reference/search-apis/search/
  */
@@ -16,6 +18,28 @@ public function __construct(
         protected array $response,
     ) {}
 
+    /**
+     * Create a fake search response instance.
+     *
+     * @param  array<int, Document|Hit|array<string, mixed>>  $hits
+     */
+    public static function fake(array $hits = [], string $index = 'test'): static
+    {
+        return new static([
+            'hits' => [
+                'total' => [
+                    'value' => count($hits),
+                    'relation' => 'eq',
+                ],
+                'hits' => array_map(fn (Document|Hit|array $hit, int $position) => match (true) {
+                    $hit instanceof Hit => $hit->raw(),
+                    $hit instanceof Document => Hit::fake($hit, $index)->raw(),
+                    default => Hit::fake($hit, $index, (string) ($position + 1))->raw(),
+                }, array_values($hits), array_keys(array_values($hits))),
+            ],
+        ]);
+    }
+
     /**
      * Get the search hits.
      *

src/Testing/Fakes/FakeDocumentManager.php

@@ -42,22 +42,16 @@ class FakeDocumentManager implements DocumentManagerInterface
      */
     protected array $searched = [];
 
-    /**
-     * The response that should be returned for searches.
-     */
-    protected SearchResponse $response;
-
     /**
      * Create a new fake document manager instance.
      */
-    public function __construct()
-    {
-        $this->response = new SearchResponse([
+    public function __construct(
+        protected SearchResponse $response = new SearchResponse([
             'hits' => [
                 'hits' => [],
             ],
-        ]);
-    }
+        ]),
+    ) {}
 
     /**
      * Set the search response returned by the fake.

tests/Unit/Documents/DocumentTest.php

@@ -13,6 +13,13 @@
     $this->assertNull($document->get('missing'));
 });
 
+test('fake document can be created', function () {
+    $document = Document::fake('123456', ['title' => 'book']);
+
+    expect($document->id())->toBe('123456')
+        ->and($document->source())->toBe(['title' => 'book']);
+});
+
 test('array casting', function () {
     $document = new Document('1', ['title' => 'test']);
 

tests/Unit/Documents/FakeDocumentManagerTest.php

@@ -84,3 +84,9 @@
 
     $documents->assertSearched('posts', $request);
 });
+
+test('fake document manager can be constructed with a search response', function () {
+    $documents = new FakeDocumentManager($response = SearchResponse::fake());
+
+    expect($documents->search('posts', new SearchRequest))->toBe($response);
+});

tests/Unit/Search/HitTest.php

@@ -54,6 +54,38 @@
     $this->assertSame('test', $this->hit->index());
 });
 
+test('fake hit can be created from source', function () {
+    $hit = Hit::fake(['title' => 'foo'], index: 'posts', id: '123', score: 4.2);
+
+    expect($hit->index())->toBe('posts')
+        ->and($hit->id())->toBe('123')
+        ->and($hit->score())->toBe(4.2)
+        ->and($hit->source())->toBe(['title' => 'foo']);
+});
+
+test('fake hit can be created from a document', function () {
+    $hit = Hit::fake(Document::fake('123', ['title' => 'foo']), index: 'posts');
+
+    expect($hit->index())->toBe('posts')
+        ->and($hit->id())->toBe('123')
+        ->and($hit->source())->toBe(['title' => 'foo']);
+});
+
+test('fake hit can be created from raw hit attributes', function () {
+    $hit = Hit::fake([
+        '_index' => 'articles',
+        '_id' => 'post-1',
+        '_score' => 4.2,
+        '_source' => [
+            'title' => 'First',
+        ],
+    ]);
+
+    expect($hit->index())->toBe('articles')
+        ->and($hit->id())->toBe('post-1')
+        ->and($hit->score())->toBe(4.2);
+});
+
 test('document can be retrieved', function () {
     $this->assertEquals(
         new Document('1', ['title' => 'foo']),

tests/Unit/Search/SearchResponseTest.php

@@ -2,6 +2,7 @@
 
 namespace DirectoryTree\OpenSearchAdapter\Tests\Unit\Search;
 
+use DirectoryTree\OpenSearchAdapter\Documents\Document;
 use DirectoryTree\OpenSearchAdapter\Search\Aggregation;
 use DirectoryTree\OpenSearchAdapter\Search\Hit;
 use DirectoryTree\OpenSearchAdapter\Search\SearchResponse;
@@ -190,3 +191,48 @@
         ],
     ], $searchResponse->raw());
 });
+
+test('fake response can be created without hits', function () {
+    $searchResponse = SearchResponse::fake();
+
+    expect($searchResponse->hits())->toBe([])
+        ->and($searchResponse->total())->toBe(0);
+});
+
+test('fake response can be created with documents', function () {
+    $searchResponse = SearchResponse::fake([
+        new Document('1', ['title' => 'First']),
+        new Document('2', ['title' => 'Second']),
+    ], 'posts');
+
+    expect($searchResponse->total())->toBe(2)
+        ->and($searchResponse->hits()[0]->index())->toBe('posts')
+        ->and($searchResponse->hits()[0]->id())->toBe('1')
+        ->and($searchResponse->hits()[0]->source())->toBe(['title' => 'First']);
+});
+
+test('fake response can be created with source arrays', function () {
+    $searchResponse = SearchResponse::fake([
+        ['title' => 'First'],
+    ]);
+
+    expect($searchResponse->hits()[0]->id())->toBe('1')
+        ->and($searchResponse->hits()[0]->source())->toBe(['title' => 'First']);
+});
+
+test('fake response can be created with raw hits', function () {
+    $searchResponse = SearchResponse::fake([
+        [
+            '_index' => 'articles',
+            '_id' => 'post-1',
+            '_score' => 4.2,
+            '_source' => [
+                'title' => 'First',
+            ],
+        ],
+    ]);
+
+    expect($searchResponse->hits()[0]->index())->toBe('articles')
+        ->and($searchResponse->hits()[0]->id())->toBe('post-1')
+        ->and($searchResponse->hits()[0]->score())->toBe(4.2);
+});