chewy 0.8.4 → 7.3.4

data/spec/chewy/search/response_spec.rb

@@ -0,0 +1,202 @@
+require 'spec_helper'
+
+describe Chewy::Search::Response, :orm do
+  before { Chewy.massacre }
+
+  before do
+    stub_model(:city)
+    stub_model(:country)
+
+    stub_index(:cities) do
+      index_scope City
+      field :name
+      field :rating, type: 'integer'
+    end
+    stub_index(:countries) do
+      index_scope Country
+      field :name
+      field :rating, type: 'integer'
+    end
+  end
+
+  before do
+    CitiesIndex.import!(cities: cities)
+    CountriesIndex.import!(countries)
+  end
+
+  let(:cities) { Array.new(2) { |i| City.create!(rating: i, name: "city #{i}") } }
+  let(:countries) { Array.new(2) { |i| Country.create!(rating: i + 2, name: "country #{i}") } }
+
+  let(:request) { Chewy::Search::Request.new(CitiesIndex, CountriesIndex).order(:rating) }
+  let(:raw_response) { request.send(:perform) }
+  let(:load_options) { {} }
+  let(:loader) { Chewy::Search::Loader.new(indexes: [CitiesIndex, CountriesIndex], **load_options) }
+  subject { described_class.new(raw_response, loader) }
+
+  describe '#hits' do
+    specify { expect(subject.hits).to be_a(Array) }
+    specify { expect(subject.hits).to have(4).items }
+    specify { expect(subject.hits).to all be_a(Hash) }
+    specify do
+      expect(subject.hits.flat_map(&:keys).uniq)
+        .to match_array(%w[_id _index _type _score _source sort])
+    end
+
+    context do
+      let(:raw_response) { {} }
+      specify { expect(subject.hits).to eq([]) }
+    end
+  end
+
+  describe '#total' do
+    specify { expect(subject.total).to eq(4) }
+
+    context do
+      let(:raw_response) { {} }
+      specify { expect(subject.total).to eq(0) }
+    end
+  end
+
+  describe '#max_score' do
+    specify { expect(subject.max_score).to be_nil }
+
+    context do
+      let(:request) { Chewy::Search::Request.new(CitiesIndex).query(range: {rating: {lte: 42}}) }
+      specify { expect(subject.max_score).to eq(1.0) }
+    end
+  end
+
+  describe '#took' do
+    specify { expect(subject.took).to be >= 0 }
+
+    context do
+      let(:request) do
+        Chewy::Search::Request.new(CitiesIndex)
+          .query(script: {script: {inline: 'sleep(100); true', lang: 'groovy'}})
+      end
+      specify do
+        pending
+        expect(subject.took).to be > 100
+      end
+    end
+  end
+
+  describe '#timed_out?' do
+    specify { expect(subject.timed_out?).to eq(false) }
+
+    context do
+      let(:request) do
+        Chewy::Search::Request.new(CitiesIndex)
+          .query(script: {script: {inline: 'sleep(100); true', lang: 'groovy'}}).timeout('10ms')
+      end
+      specify do
+        pending
+        expect(subject.timed_out?).to eq(true)
+      end
+    end
+  end
+
+  describe '#suggest' do
+    specify { expect(subject.suggest).to eq({}) }
+
+    context do
+      let(:request) do
+        Chewy::Search::Request.new(CitiesIndex).suggest(
+          my_suggestion: {
+            text: 'city country',
+            term: {
+              field: 'name'
+            }
+          }
+        )
+      end
+      specify do
+        expect(subject.suggest).to eq(
+          'my_suggestion' => [
+            {'text' => 'city', 'offset' => 0, 'length' => 4, 'options' => []},
+            {'text' => 'country', 'offset' => 5, 'length' => 7, 'options' => []}
+          ]
+        )
+      end
+    end
+  end
+
+  describe '#aggs' do
+    specify { expect(subject.aggs).to eq({}) }
+
+    context do
+      let(:request) do
+        Chewy::Search::Request.new(CitiesIndex, CountriesIndex).aggs(avg_rating: {avg: {field: :rating}})
+      end
+      specify { expect(subject.aggs).to eq('avg_rating' => {'value' => 1.5}) }
+    end
+  end
+
+  describe '#wrappers' do
+    specify { expect(subject.wrappers).to be_a(Array) }
+    specify { expect(subject.wrappers).to have(4).items }
+    specify do
+      expect(subject.wrappers.map(&:class).uniq)
+        .to contain_exactly(CitiesIndex, CountriesIndex)
+    end
+    specify { expect(subject.wrappers.map(&:_data)).to eq(subject.hits) }
+
+    context do
+      let(:raw_response) { {} }
+      specify { expect(subject.wrappers).to eq([]) }
+    end
+
+    context do
+      let(:raw_response) { {'hits' => {}} }
+      specify { expect(subject.wrappers).to eq([]) }
+    end
+
+    context do
+      let(:raw_response) { {'hits' => {'hits' => []}} }
+      specify { expect(subject.wrappers).to eq([]) }
+    end
+
+    context do
+      let(:raw_response) do
+        {'hits' => {'hits' => [
+          {'_index' => 'cities',
+           '_type' => 'city',
+           '_id' => '1',
+           '_score' => 1.3,
+           '_source' => {'id' => 2, 'rating' => 0}}
+        ]}}
+      end
+      specify { expect(subject.wrappers.first).to be_a(CitiesIndex) }
+      specify { expect(subject.wrappers.first.id).to eq(2) }
+      specify { expect(subject.wrappers.first.rating).to eq(0) }
+      specify { expect(subject.wrappers.first._score).to eq(1.3) }
+      specify { expect(subject.wrappers.first._explanation).to be_nil }
+    end
+
+    context do
+      let(:raw_response) do
+        {'hits' => {'hits' => [
+          {'_index' => 'countries',
+           '_type' => 'country',
+           '_id' => '2',
+           '_score' => 1.2,
+           '_explanation' => {foo: 'bar'}}
+        ]}}
+      end
+      specify { expect(subject.wrappers.first).to be_a(CountriesIndex) }
+      specify { expect(subject.wrappers.first.id).to eq('2') }
+      specify { expect(subject.wrappers.first.rating).to be_nil }
+      specify { expect(subject.wrappers.first._score).to eq(1.2) }
+      specify { expect(subject.wrappers.first._explanation).to eq(foo: 'bar') }
+    end
+  end
+
+  describe '#objects' do
+    specify { expect(subject.objects).to eq([*cities, *countries]) }
+  end
+
+  describe '#object_hash' do
+    specify { expect(subject.object_hash.keys).to eq(subject.wrappers) }
+    specify { expect(subject.object_hash.values).to eq(subject.objects) }
+  end
+end

data/spec/chewy/search/scrolling_spec.rb

@@ -0,0 +1,171 @@
+require 'spec_helper'
+
+describe Chewy::Search::Scrolling, :orm do
+  before { Chewy.massacre }
+
+  before do
+    stub_model(:city)
+    stub_model(:country)
+
+    stub_index(:cities) do
+      index_scope City
+      field :name
+      field :rating, type: 'integer'
+    end
+    stub_index(:countries) do
+      index_scope Country
+      field :name
+      field :rating, type: 'integer'
+    end
+  end
+
+  let(:request) { Chewy::Search::Request.new(CitiesIndex, CountriesIndex).order(:rating) }
+
+  specify { expect(request.scroll_batches.to_a).to eq([]) }
+
+  context do
+    before do
+      CitiesIndex.import!(cities)
+      CountriesIndex.import!(countries: countries)
+    end
+
+    let(:cities) { Array.new(2) { |i| City.create!(rating: i, name: "city #{i}") } }
+    let(:countries) { Array.new(3) { |i| Country.create!(rating: i + 2, name: "country #{i}") } }
+
+    describe '#scroll_batches' do
+      context do
+        before { expect(Chewy.client).to receive(:scroll).twice.and_call_original }
+        specify do
+          expect(request.scroll_batches(batch_size: 2).map do |batch|
+            batch.map { |hit| hit['_source']['rating'] }
+          end).to eq([[0, 1], [2, 3], [4]])
+        end
+      end
+
+      context do
+        before { expect(Chewy.client).to receive(:scroll).once.and_call_original }
+        specify do
+          expect(request.scroll_batches(batch_size: 3).map do |batch|
+            batch.map { |hit| hit['_source']['rating'] }
+          end).to eq([[0, 1, 2], [3, 4]])
+        end
+      end
+
+      context do
+        before { expect(Chewy.client).to receive(:scroll).once.and_call_original }
+        it 'respects limit' do
+          expect(request.limit(4).scroll_batches(batch_size: 3).map do |batch|
+            batch.map { |hit| hit['_source']['rating'] }
+          end).to eq([[0, 1, 2], [3]])
+        end
+      end
+
+      context do
+        before { expect(Chewy.client).not_to receive(:scroll) }
+        it 'respects limit and terminate_after' do
+          expect(request.terminate_after(1).limit(4).scroll_batches(batch_size: 3).map do |batch|
+            batch.map { |hit| hit['_source']['rating'] }
+          end).to eq([[0, 2]])
+        end
+      end
+
+      context do
+        before { expect(Chewy.client).not_to receive(:scroll) }
+        it 'respects limit' do
+          expect(request.limit(3).scroll_batches(batch_size: 3).map do |batch|
+            batch.map { |hit| hit['_source']['rating'] }
+          end).to eq([[0, 1, 2]])
+        end
+      end
+
+      context do
+        before { expect(Chewy.client).not_to receive(:scroll) }
+        it 'respects limit' do
+          expect(request.limit(2).scroll_batches(batch_size: 3).map do |batch|
+            batch.map { |hit| hit['_source']['rating'] }
+          end).to eq([[0, 1]])
+        end
+      end
+
+      context do
+        before { expect(Chewy.client).not_to receive(:scroll) }
+        specify do
+          expect(request.scroll_batches(batch_size: 5).map do |batch|
+            batch.map { |hit| hit['_source']['rating'] }
+          end).to eq([[0, 1, 2, 3, 4]])
+        end
+      end
+
+      context do
+        before { expect(Chewy.client).not_to receive(:scroll) }
+        specify do
+          expect(request.scroll_batches(batch_size: 10).map do |batch|
+            batch.map { |hit| hit['_source']['rating'] }
+          end).to eq([[0, 1, 2, 3, 4]])
+        end
+      end
+
+      it 'clears the scroll after completion' do
+        expect(Chewy.client).to receive(:clear_scroll).with(body: {scroll_id: anything}).once.and_call_original
+        request.scroll_batches(batch_size: 3) {}
+      end
+
+      context 'instrumentation' do
+        specify do
+          outer_payload = []
+          ActiveSupport::Notifications.subscribe('search_query.chewy') do |_name, _start, _finish, _id, payload|
+            outer_payload << payload
+          end
+          request.scroll_batches(batch_size: 3).to_a
+          expect(outer_payload).to match_array([
+            hash_including(
+              index: [CitiesIndex, CountriesIndex],
+              indexes: [CitiesIndex, CountriesIndex],
+              request: {index: %w[cities countries], body: {sort: ['rating']}, size: 3, scroll: '1m'}
+            ),
+            hash_including(
+              index: [CitiesIndex, CountriesIndex],
+              indexes: [CitiesIndex, CountriesIndex],
+              request: {scroll: '1m', scroll_id: an_instance_of(String)}
+            )
+          ])
+        end
+      end
+    end
+
+    describe '#scroll_hits' do
+      before { expect(Chewy.client).to receive(:scroll).twice.and_call_original }
+      specify do
+        expect(request.scroll_hits(batch_size: 2).map do |hit|
+          hit['_source']['rating']
+        end).to eq([0, 1, 2, 3, 4])
+      end
+    end
+
+    describe '#scroll_wrappers' do
+      before { expect(Chewy.client).to receive(:scroll).twice.and_call_original }
+
+      specify do
+        expect(request.scroll_wrappers(batch_size: 2).map(&:rating))
+          .to eq([0, 1, 2, 3, 4])
+      end
+      specify do
+        expect(request.scroll_wrappers(batch_size: 2).map(&:class).uniq)
+          .to eq([CitiesIndex, CountriesIndex])
+      end
+    end
+
+    describe '#scroll_objects' do
+      before { expect(Chewy.client).to receive(:scroll).twice.and_call_original }
+
+      specify do
+        expect(request.scroll_objects(batch_size: 2).map(&:rating))
+          .to eq([0, 1, 2, 3, 4])
+      end
+      specify do
+        expect(request.scroll_objects(batch_size: 2).map(&:class).uniq)
+          .to eq([City, Country])
+      end
+    end
+  end
+end

data/spec/chewy/search_spec.rb

@@ -4,41 +4,34 @@ describe Chewy::Search do
   before { Chewy.massacre }
 
   before do
-    stub_index(:products) do
-      define_type :product
-      define_type :product2
-    end
+    stub_index(:products)
   end
 
-  let(:product) { ProductsIndex::Product }
-
   describe '.all' do
-    specify { expect(ProductsIndex.all).to be_a(Chewy::Query) }
-    specify { expect(product.all).to be_a(Chewy::Query) }
+    specify { expect(ProductsIndex.all).to be_a(Chewy::Search::Request) }
+
+    context do
+      before { allow(Chewy).to receive_messages(search_class: Chewy::Search::Request) }
+
+      specify { expect(ProductsIndex.all).to be_a(Chewy::Search::Request) }
+    end
   end
 
   describe '.search_string' do
     specify do
-      expect(ProductsIndex.client).to receive(:search).with(hash_including(q: 'hello')).twice
+      expect(ProductsIndex.client).to receive(:search).with(hash_including(q: 'hello')).once
       ProductsIndex.search_string('hello')
-      product.search_string('hello')
     end
 
     specify do
-      expect(ProductsIndex.client).to receive(:search).with(hash_including(explain: true)).twice
+      expect(ProductsIndex.client).to receive(:search).with(hash_including(explain: true)).once
       ProductsIndex.search_string('hello', explain: true)
-      product.search_string('hello', explain: true)
     end
 
     specify do
-      expect(ProductsIndex.client).to receive(:search).with(hash_including(index: ['products'], type: []))
+      expect(ProductsIndex.client).to receive(:search).with(hash_including(index: ['products'])).once
       ProductsIndex.search_string('hello')
     end
-
-    specify do
-      expect(ProductsIndex.client).to receive(:search).with(hash_including(index: ['products'], type: ['product']))
-      product.search_string('hello')
-    end
   end
 
   context 'named scopes' do
@@ -46,55 +39,89 @@ describe Chewy::Search do
       stub_model(:city)
       stub_model(:country)
 
-      stub_index(:places) do
+      stub_index(:cities) do
         def self.by_rating(value)
-          filter { rating == value }
+          filter { match rating: value }
         end
 
         def self.by_name(index)
-          filter { name == "Name#{index}" }
+          filter { match name: "Name#{index}" }
+        end
+
+        def self.by_rating_with_kwargs(value, options:) # rubocop:disable Lint/UnusedMethodArgument
+          filter { match rating: value }
         end
 
-        define_type City do
-          def self.by_rating
-            filter { rating == yield }
-          end
+        index_scope City
+        field :name, type: 'keyword'
+        field :rating, type: :integer
+      end
 
-          field :name, index: 'not_analyzed'
-          field :rating, type: :integer
+      stub_index(:countries) do
+        def self.by_rating(value)
+          filter { match rating: value }
         end
 
-        define_type Country do
-          field :name, index: 'not_analyzed'
-          field :rating, type: :integer
+        def self.by_name(index)
+          filter { match name: "Name#{index}" }
         end
+
+        index_scope Country
+        field :name, type: 'keyword'
+        field :rating, type: :integer
       end
     end
 
-    let!(:cities) { 3.times.map { |i| City.create! rating: i + 1, name: "Name#{i+1}" } }
-    let!(:countries) { 3.times.map { |i| Country.create! rating: i + 1, name: "Name#{i+4}" } }
-
-    before { PlacesIndex.import! city: cities, country: countries }
-
-    specify { expect(PlacesIndex.by_rating(1).map(&:rating)).to eq([1, 1]) }
-    specify { expect(PlacesIndex.by_rating(1).map(&:class)).to match_array([PlacesIndex::City, PlacesIndex::Country]) }
-    specify { expect(PlacesIndex.by_rating(1).by_name(1).map(&:rating)).to eq([1]) }
-    specify { expect(PlacesIndex.by_rating(1).by_name(1).map(&:class)).to eq([PlacesIndex::City]) }
-    specify { expect(PlacesIndex.order(:name).by_rating(1).map(&:rating)).to eq([1, 1]) }
-    specify { expect(PlacesIndex.order(:name).by_rating(1).map(&:class)).to match_array([PlacesIndex::City, PlacesIndex::Country]) }
-
-    specify { expect(PlacesIndex::City.by_rating {2}.map(&:rating)).to eq([2]) }
-    specify { expect(PlacesIndex::City.by_rating {2}.map(&:class)).to eq([PlacesIndex::City]) }
-    specify { expect(PlacesIndex::City.by_rating {2}.by_name(2).map(&:rating)).to eq([2]) }
-    specify { expect(PlacesIndex::City.by_rating {2}.by_name(2).map(&:class)).to eq([PlacesIndex::City]) }
-    specify { expect(PlacesIndex::City.order(:name).by_rating {2}.map(&:rating)).to eq([2]) }
-    specify { expect(PlacesIndex::City.order(:name).by_rating {2}.map(&:class)).to eq([PlacesIndex::City]) }
-
-    specify { expect(PlacesIndex::Country.by_rating(3).map(&:rating)).to eq([3]) }
-    specify { expect(PlacesIndex::Country.by_rating(3).map(&:class)).to eq([PlacesIndex::Country]) }
-    specify { expect(PlacesIndex::Country.by_rating(3).by_name(6).map(&:rating)).to eq([3]) }
-    specify { expect(PlacesIndex::Country.by_rating(3).by_name(6).map(&:class)).to eq([PlacesIndex::Country]) }
-    specify { expect(PlacesIndex::Country.order(:name).by_rating(3).map(&:rating)).to eq([3]) }
-    specify { expect(PlacesIndex::Country.order(:name).by_rating(3).map(&:class)).to eq([PlacesIndex::Country]) }
+    let!(:cities) { Array.new(3) { |i| City.create! rating: i + 1, name: "Name#{i + 2}" } }
+    let!(:countries) { Array.new(3) { |i| Country.create! rating: i + 1, name: "Name#{i + 3}" } }
+
+    before do
+      CitiesIndex.import!(cities)
+      CountriesIndex.import!(country: countries)
+    end
+
+    specify { expect(CitiesIndex.indices(CountriesIndex).by_rating(1).map(&:rating)).to eq([1, 1]) }
+    specify do
+      expect(CitiesIndex.indices(CountriesIndex).by_rating(1).map(&:class))
+        .to match_array([CitiesIndex, CountriesIndex])
+    end
+    specify { expect(CitiesIndex.indices(CountriesIndex).by_rating(1).by_name(2).map(&:rating)).to eq([1]) }
+    specify do
+      expect(CitiesIndex.indices(CountriesIndex).by_rating(1).by_name(2).map(&:class))
+        .to eq([CitiesIndex])
+    end
+    specify { expect(CitiesIndex.indices(CountriesIndex).by_name(3).map(&:rating)).to eq([2, 1]) }
+    specify do
+      expect(CitiesIndex.indices(CountriesIndex).by_name(3).map(&:class))
+        .to eq([CitiesIndex, CountriesIndex])
+    end
+    specify { expect(CitiesIndex.indices(CountriesIndex).order(:name).by_rating(1).map(&:rating)).to eq([1, 1]) }
+    specify do
+      expect(CitiesIndex.indices(CountriesIndex).order(:name).by_rating(1).map(&:class))
+        .to match_array([CitiesIndex, CountriesIndex])
+    end
+
+    specify { expect(CitiesIndex.by_rating(2).map(&:rating)).to eq([2]) }
+    specify { expect(CitiesIndex.by_rating(2).map(&:class)).to eq([CitiesIndex]) }
+    specify { expect(CitiesIndex.by_rating(2).by_name(3).map(&:rating)).to eq([2]) }
+    specify { expect(CitiesIndex.by_rating(2).by_name(3).map(&:class)).to eq([CitiesIndex]) }
+    specify { expect(CitiesIndex.by_name(3).map(&:rating)).to eq([2]) }
+    specify { expect(CitiesIndex.by_name(3).map(&:rating)).to eq([2]) }
+    specify { expect(CitiesIndex.order(:name).by_name(3).map(&:rating)).to eq([2]) }
+    specify { expect(CitiesIndex.order(:name).by_name(3).map(&:rating)).to eq([2]) }
+    specify { expect(CitiesIndex.order(:name).by_rating(2).map(&:rating)).to eq([2]) }
+    specify { expect(CitiesIndex.order(:name).by_rating(2).map(&:class)).to eq([CitiesIndex]) }
+
+    specify { expect(CountriesIndex.by_rating(3).map(&:rating)).to eq([3]) }
+    specify { expect(CountriesIndex.by_rating(3).map(&:class)).to eq([CountriesIndex]) }
+    specify { expect(CountriesIndex.by_rating(3).by_name(5).map(&:rating)).to eq([3]) }
+    specify { expect(CountriesIndex.by_rating(3).by_name(5).map(&:class)).to eq([CountriesIndex]) }
+    specify { expect(CountriesIndex.order(:name).by_rating(3).map(&:rating)).to eq([3]) }
+    specify { expect(CountriesIndex.order(:name).by_rating(3).map(&:class)).to eq([CountriesIndex]) }
+
+    specify 'supports keyword arguments' do
+      expect(CitiesIndex.by_rating_with_kwargs(3, options: 'blah blah blah').map(&:rating)).to eq([3])
+      expect(CitiesIndex.order(:name).by_rating_with_kwargs(3, options: 'blah blah blah').map(&:rating)).to eq([3])
+    end
   end
 end

data/spec/chewy/stash_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe Chewy::Stash::Journal, :orm do
+  def fetch_deleted_number(response)
+    response['deleted'] || response['_indices']['_all']['deleted']
+  end
+
+  before { Chewy.massacre }
+
+  before do
+    stub_model(:city)
+    stub_index(:cities) do
+      index_scope City
+    end
+    stub_index(:countries)
+    stub_index(:users)
+    stub_index(:borogoves)
+  end
+
+  before { Timecop.freeze }
+  after { Timecop.return }
+
+  before do
+    CitiesIndex.import!(City.new(id: 1, name: 'City'), journal: true)
+    Timecop.travel(Time.now + 1.minute) do
+      CountriesIndex.import!([id: 2, name: 'Country'], journal: true)
+    end
+    Timecop.travel(Time.now + 2.minutes) do
+      UsersIndex.import!([id: 3, name: 'User'], journal: true)
+    end
+  end
+
+  describe '.entries' do
+    specify do
+      expect(described_class.entries(Time.now - 30.seconds).map(&:references))
+        .to contain_exactly([1], [{'id' => 2, 'name' => 'Country'}], [{'id' => 3, 'name' => 'User'}])
+    end
+    specify do
+      expect(described_class.entries(Time.now + 30.seconds).map(&:references))
+        .to contain_exactly([{'id' => 2, 'name' => 'Country'}], [{'id' => 3, 'name' => 'User'}])
+    end
+    specify do
+      expect(described_class.entries(Time.now + 90.seconds).map(&:references))
+        .to contain_exactly([{'id' => 3, 'name' => 'User'}])
+    end
+
+    specify do
+      expect(described_class.entries(Time.now - 30.seconds, only: UsersIndex).map(&:references))
+        .to contain_exactly([{'id' => 3, 'name' => 'User'}])
+    end
+    specify do
+      expect(described_class.entries(Time.now - 30.seconds, only: [CitiesIndex, UsersIndex]).map(&:references))
+        .to contain_exactly([1], [{'id' => 3, 'name' => 'User'}])
+    end
+    specify do
+      expect(described_class.entries(Time.now + 30.seconds, only: [CitiesIndex, UsersIndex]).map(&:references))
+        .to contain_exactly([{'id' => 3, 'name' => 'User'}])
+    end
+    specify do
+      expect(described_class.entries(Time.now + 30.seconds, only: [BorogovesIndex])).to eq([])
+    end
+  end
+
+  describe '.clean' do
+    specify { expect(fetch_deleted_number(described_class.clean)).to eq(3) }
+    specify { expect(fetch_deleted_number(described_class.clean(Time.now - 30.seconds))).to eq(0) }
+    specify { expect(fetch_deleted_number(described_class.clean(Time.now + 30.seconds))).to eq(1) }
+    specify { expect(fetch_deleted_number(described_class.clean(Time.now + 90.seconds))).to eq(2) }
+    specify { expect(fetch_deleted_number(described_class.clean(only: BorogovesIndex))).to eq(0) }
+    specify { expect(fetch_deleted_number(described_class.clean(only: UsersIndex))).to eq(1) }
+    specify { expect(fetch_deleted_number(described_class.clean(only: [CitiesIndex, UsersIndex]))).to eq(2) }
+
+    specify do
+      expect(fetch_deleted_number(described_class.clean(Time.now + 30.seconds, only: CountriesIndex))).to eq(0)
+    end
+    specify { expect(fetch_deleted_number(described_class.clean(Time.now + 30.seconds, only: CitiesIndex))).to eq(1) }
+  end
+
+  describe '.for' do
+    specify { expect(described_class.for(UsersIndex).map(&:index_name)).to eq(['users']) }
+    specify do
+      expect(described_class.for(CitiesIndex, UsersIndex).map(&:index_name)).to contain_exactly('cities', 'users')
+    end
+  end
+end