Add new assertion 'assertCount' (#20)

* Add new assertion 'assertCount'

* Added 'whereNotIn' filter

* fix tests

Author: JoseVte

.gitignore

@@ -1,4 +1,5 @@
 /vendor
+/.idea
 /.env
 composer.phar
 composer.lock

README.md

@@ -174,6 +174,30 @@ User::factory()->create();
 Search::assertNotEmptyIn('users'); // ✅
 ```
 
+### assertCount($count)
+
+Checks if there is at least one record in any of search indexes.
+
+```php
+Search::assertCount(1); // ❌
+
+User::factory()->create();
+
+Search::assertCount(1); // ✅
+```
+
+### assertCountIn($index)
+
+Checks if search index is not empty.
+
+```php
+Search::assertNotEmptyIn('users', 1); // ❌
+
+User::factory()->create();
+
+Search::assertNotEmptyIn('users', 1); // ✅
+```
+
 ### 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.

src/ArrayStore.php

@@ -83,6 +83,11 @@ public function mock(string $index, string $key, array $data, bool $merge = true
         $this->setData('mocks', $index, Arr::prepend($this->getRecordsExcept('current', $key, $index), $data));
     }
 
+    public function getDefaultIndex(string $type = 'current'): string
+    {
+        return Arr::first(array_keys($this->storage[$type])) ?? '';
+    }
+
     private function add(string $type, string $index, string $key, array $data, bool $removeOld = true): void
     {
         $array = &$this->storage[$type];

src/Engines/ArrayEngine.php

@@ -34,7 +34,7 @@ public function __construct($store, $softDelete = false)
     /**
      * Update the given model in the index.
      *
-     * @param  Collection  $models
+     * @param Collection $models
      * @return void
      */
     public function update($models)
@@ -58,7 +58,7 @@ public function update($models)
     /**
      * Remove the given model from the index.
      *
-     * @param  Collection  $models
+     * @param Collection $models
      * @return void
      */
     public function delete($models)
@@ -84,8 +84,8 @@ public function search(Builder $builder)
     /**
      * Perform the given search on the engine.
      *
-     * @param  int  $perPage
-     * @param  int  $page
+     * @param int $perPage
+     * @param int $page
      * @return mixed
      */
     public function paginate(Builder $builder, $perPage, $page)
@@ -99,7 +99,7 @@ public function paginate(Builder $builder, $perPage, $page)
     /**
      * Perform the given search on the engine.
      *
-     * @return mixed
+     * @return array
      */
     protected function performSearch(Builder $builder, array $options = [])
     {
@@ -108,9 +108,12 @@ protected function performSearch(Builder $builder, array $options = [])
         $matches = $this->store->find($index, function ($record) use ($builder) {
             $values = new RecursiveIteratorIterator(new RecursiveArrayIterator($record));
 
-            return $this->matchesFilters($record, $builder->wheres) && ! empty(array_filter(iterator_to_array($values, false), function ($value) use ($builder) {
-                return ! $builder->query || stripos($value, $builder->query) !== false;
-            }));
+            return $this->matchesFilters($record, $builder->wheres) &&
+                $this->matchesFilters($record, $builder->whereIns) &&
+                $this->matchesFilters($record, data_get($builder, 'whereNotIns', []), true) &&
+                !empty(array_filter(iterator_to_array($values, false), function ($value) use ($builder) {
+                    return !$builder->query || stripos($value, $builder->query) !== false;
+                }));
         }, true);
 
         $matches = Collection::make($matches);
@@ -124,25 +127,46 @@ protected function performSearch(Builder $builder, array $options = [])
     /**
      * Determine if the given record matches given filters.
      *
-     * @param  array  $record
-     * @param  array  $filters
+     * @param array $record
+     * @param array $filters
+     * @param bool $not
      * @return bool
      */
-    private function matchesFilters($record, $filters)
+    private function matchesFilters($record, $filters, $not = false)
     {
         if (empty($filters)) {
             return true;
         }
 
-        return Collection::make($filters)->every(function ($value, $key) use ($record) {
-            return $record[$key] === $value;
+        $match = function ($record, $key, $value) {
+            if (is_array($value)) {
+                return in_array(data_get($record, $key), $value, true);
+            }
+            return data_get($record, $key) === $value;
+        };
+
+        $match = Collection::make($filters)->every(function ($value, $key) use ($match, $record) {
+            $keyExploded = explode('.', $key);
+            if (count($keyExploded) > 1) {
+                if (data_get($record, $keyExploded[0]) instanceof Collection) {
+                    return data_get($record, $keyExploded[0])->contains(function ($subRecord) use ($match, $keyExploded, $value) {
+                        return $match($subRecord, $keyExploded[1], $value);
+                    });
+                }
+
+                return $match($record, $keyExploded, $value);
+            }
+
+            return $match($record, $key, $value);
         });
+
+        return $not ? !$match : $match;
     }
 
     /**
      * Pluck and return the primary keys of the given results.
      *
-     * @param  mixed  $results
+     * @param mixed $results
      * @return \Illuminate\Support\Collection
      */
     public function mapIds($results)
@@ -153,8 +177,8 @@ public function mapIds($results)
     /**
      * Map the given results to instances of the given model.
      *
-     * @param  mixed  $results
-     * @param  \Illuminate\Database\Eloquent\Model  $model
+     * @param mixed $results
+     * @param \Illuminate\Database\Eloquent\Model $model
      * @return Collection
      */
     public function map(Builder $builder, $results, $model)
@@ -177,8 +201,8 @@ public function map(Builder $builder, $results, $model)
     /**
      * Map the given results to instances of the given model via a lazy collection.
      *
-     * @param  mixed  $results
-     * @param  \Illuminate\Database\Eloquent\Model  $model
+     * @param mixed $results
+     * @param \Illuminate\Database\Eloquent\Model $model
      * @return \Illuminate\Support\LazyCollection
      */
     public function lazyMap(Builder $builder, $results, $model)
@@ -203,7 +227,7 @@ public function lazyMap(Builder $builder, $results, $model)
     /**
      * Get the total count from a raw result returned by the engine.
      *
-     * @param  mixed  $results
+     * @param mixed $results
      * @return int
      */
     public function getTotalCount($results)
@@ -214,7 +238,7 @@ public function getTotalCount($results)
     /**
      * Flush all of the model's records from the engine.
      *
-     * @param  \Illuminate\Database\Eloquent\Model  $model
+     * @param \Illuminate\Database\Eloquent\Model $model
      * @return void
      */
     public function flush($model)
@@ -225,7 +249,7 @@ public function flush($model)
     /**
      * Create a search index.
      *
-     * @param  string  $name
+     * @param string $name
      * @return mixed
      */
     public function createIndex($name, array $options = [])
@@ -236,7 +260,7 @@ public function createIndex($name, array $options = [])
     /**
      * Delete a search index.
      *
-     * @param  string  $name
+     * @param string $name
      * @return mixed
      */
     public function deleteIndex($name)
@@ -247,11 +271,25 @@ public function deleteIndex($name)
     /**
      * Determine if the given model uses soft deletes.
      *
-     * @param  \Illuminate\Database\Eloquent\Model  $model
+     * @param \Illuminate\Database\Eloquent\Model $model
      * @return bool
      */
     protected function usesSoftDelete($model)
     {
         return in_array(SoftDeletes::class, class_uses_recursive($model));
     }
+
+    protected function buildSearchQuery(Builder $builder)
+    {
+        $query = $this->initializeSearchQuery(
+            $builder,
+            array_keys($builder->model->toSearchableArray()),
+            $this->getPrefixColumns($builder),
+            $this->getFullTextColumns($builder)
+        );
+
+        return $this->constrainForSoftDeletes(
+            $builder, $this->addAdditionalConstraints($builder, $query->take($builder->limit))
+        );
+    }
 }

src/Search.php

@@ -103,6 +103,32 @@ public function assertNotEmptyIn(string $index): self
         return $this;
     }
 
+    public function assertCount(int $count, ?Closure $callback = null): self
+    {
+        $countFiltered = count($this->store->find($this->store->getDefaultIndex(), function ($record) use ($callback) {
+            return ($callback ? $callback($record) : true);
+        }));
+
+        Assert::assertSame(
+            $countFiltered, $count, 'Failed asserting that search index does not have the expected size.'
+        );
+
+        return $this;
+    }
+
+    public function assertCountIn(string $index, int $count, ?Closure $callback = null): self
+    {
+        $countFiltered = count($this->store->find($index, function ($record) use ($callback) {
+            return ($callback ? $callback($record) : true);
+        }));
+
+        Assert::assertSame(
+            $countFiltered, $count, "Failed asserting that '{$index}' search index does not have the expected size."
+        );
+
+        return $this;
+    }
+
     public function assertSynced(Model $model, ?Closure $callback = null): self
     {
         Assert::assertNotEmpty(

tests/Engines/ArrayEngineTest.php

@@ -415,7 +415,7 @@ public function it_can_flush_all_models_records()
     }
 
     /** @test */
-    public function it_can_be_filtered()
+    public function it_can_be_filtered_using_wheres()
     {
         $engine = new ArrayEngine(new ArrayStore());
         $engine->update(Collection::make([
@@ -435,6 +435,49 @@ public function it_can_be_filtered()
         $this->assertEquals(2, $results['hits'][0]['scoutKey']);
     }
 
+    /** @test */
+    public function it_can_be_filtered_using_where_in()
+    {
+        $engine = new ArrayEngine(new ArrayStore());
+        $engine->update(Collection::make([
+            new SearchableModel(['foo' => 'bar', 'x' => 'y', 'scoutKey' => 1]),
+            new SearchableModel(['foo' => 'baz', 'x' => 'x', 'scoutKey' => 2]),
+            new SearchableModel(['foo' => 'bax', 'x' => 'z', 'scoutKey' => 3]),
+        ]));
+
+        $builder = new Builder(new SearchableModel(), null);
+        $builder->whereIns = [
+            'foo' => ['baz'],
+            'x' => ['x', 'y']
+        ];
+        $results = $engine->search($builder);
+
+        $this->assertCount(1, $results['hits']);
+        $this->assertEquals(2, $results['hits'][0]['scoutKey']);
+    }
+
+    /** @test */
+    public function it_can_be_filtered_using_where_not_in()
+    {
+        $engine = new ArrayEngine(new ArrayStore());
+        $engine->update(Collection::make([
+            new SearchableModel(['foo' => 'bar', 'x' => 'y', 'scoutKey' => 1]),
+            new SearchableModel(['foo' => 'baz', 'x' => 'x', 'scoutKey' => 2]),
+            new SearchableModel(['foo' => 'bax', 'x' => 'z', 'scoutKey' => 3]),
+        ]));
+
+        $builder = new Builder(new SearchableModel(), null);
+        $builder->whereNotIns = [
+            'foo' => ['baz'],
+            'x' => ['x', 'y']
+        ];
+        $results = $engine->search($builder);
+
+        $this->assertCount(2, $results['hits']);
+        $this->assertEquals(3, $results['hits'][0]['scoutKey']);
+        $this->assertEquals(1, $results['hits'][1]['scoutKey']);
+    }
+
     /** @test */
     public function it_can_create_search_index()
     {