chewy 8.0.0 → 8.1.0

data/spec/chewy/search/response_spec.rb

@@ -1,180 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Search::Response, :orm do
-  before { drop_indices }
-
-  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 _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 }
-  end
-
-  describe '#timed_out?' do
-    specify { expect(subject.timed_out?).to eq(false) }
-  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

@@ -1,171 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Search::Scrolling, :orm do
-  before { drop_indices }
-
-  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

@@ -1,127 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Search do
-  before { drop_indices }
-
-  before do
-    stub_index(:products)
-  end
-
-  describe '.all' do
-    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')).once
-      ProductsIndex.search_string('hello')
-    end
-
-    specify do
-      expect(ProductsIndex.client).to receive(:search).with(hash_including(explain: true)).once
-      ProductsIndex.search_string('hello', explain: true)
-    end
-
-    specify do
-      expect(ProductsIndex.client).to receive(:search).with(hash_including(index: ['products'])).once
-      ProductsIndex.search_string('hello')
-    end
-  end
-
-  context 'named scopes' do
-    before do
-      stub_model(:city)
-      stub_model(:country)
-
-      stub_index(:cities) do
-        def self.by_rating(value)
-          filter { match rating: value }
-        end
-
-        def self.by_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
-
-        index_scope City
-        field :name, type: 'keyword'
-        field :rating, type: :integer
-      end
-
-      stub_index(:countries) do
-        def self.by_rating(value)
-          filter { match rating: value }
-        end
-
-        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) { 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

@@ -1,85 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Stash::Journal, :orm do
-  def fetch_deleted_number(response)
-    response['deleted'] || response['_indices']['_all']['deleted']
-  end
-
-  before { drop_indices }
-
-  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

data/spec/chewy/strategy/active_job_spec.rb

@@ -1,73 +0,0 @@
-require 'spec_helper'
-
-if defined?(ActiveJob)
-  describe Chewy::Strategy::ActiveJob do
-    around do |example|
-      active_job_settings = Chewy.settings[:active_job]
-      Chewy.settings[:active_job] = {queue: 'low'}
-      Chewy.strategy(:bypass) { example.run }
-      Chewy.settings[:active_job] = active_job_settings
-    end
-    before(:all) do
-      ActiveJob::Base.logger = Chewy.logger
-    end
-    before do
-      ActiveJob::Base.queue_adapter = :test
-      ActiveJob::Base.queue_adapter.enqueued_jobs.clear
-      ActiveJob::Base.queue_adapter.performed_jobs.clear
-    end
-
-    before do
-      stub_model(:city) do
-        update_index('cities') { self }
-      end
-
-      stub_index(:cities) do
-        index_scope City
-      end
-    end
-
-    let(:city) { City.create!(name: 'hello') }
-    let(:other_city) { City.create!(name: 'world') }
-
-    specify do
-      expect { [city, other_city].map(&:save!) }
-        .not_to update_index(CitiesIndex, strategy: :active_job)
-    end
-
-    specify do
-      Chewy.strategy(:active_job) do
-        [city, other_city].map(&:save!)
-      end
-      enqueued_job = ActiveJob::Base.queue_adapter.enqueued_jobs.first
-      expect(enqueued_job[:job]).to eq(Chewy::Strategy::ActiveJob::Worker)
-      expect(enqueued_job[:queue]).to eq('low')
-    end
-
-    specify do
-      Chewy.strategy(:active_job) do
-        [city, other_city].map(&:save!)
-      end
-      enqueued_job = ActiveJob::Base.queue_adapter.enqueued_jobs.first
-      expect(enqueued_job[:queue]).to eq('low')
-    end
-
-    specify do
-      ActiveJob::Base.queue_adapter = :inline
-      expect { [city, other_city].map(&:save!) }
-        .to update_index(CitiesIndex, strategy: :active_job)
-        .and_reindex(city, other_city).only
-    end
-
-    specify do
-      expect(CitiesIndex).to receive(:import!).with([city.id, other_city.id], suffix: '201601')
-      Chewy::Strategy::ActiveJob::Worker.new.perform('CitiesIndex', [city.id, other_city.id], suffix: '201601')
-    end
-
-    specify do
-      allow(Chewy).to receive(:disable_refresh_async).and_return(true)
-      expect(CitiesIndex).to receive(:import!).with([city.id, other_city.id], suffix: '201601', refresh: false)
-      Chewy::Strategy::ActiveJob::Worker.new.perform('CitiesIndex', [city.id, other_city.id], suffix: '201601')
-    end
-  end
-end

data/spec/chewy/strategy/atomic_no_refresh_spec.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Strategy::AtomicNoRefresh, :orm do
-  around { |example| Chewy.strategy(:bypass) { example.run } }
-
-  before do
-    stub_model(:country) do
-      update_index('countries') { self }
-    end
-
-    stub_index(:countries) do
-      index_scope Country
-    end
-  end
-
-  let(:country) { Country.create!(name: 'hello', country_code: 'HL') }
-  let(:other_country) { Country.create!(name: 'world', country_code: 'WD') }
-
-  specify do
-    expect { [country, other_country].map(&:save!) }
-      .to update_index(CountriesIndex, strategy: :atomic_no_refresh)
-      .and_reindex(country, other_country).only.no_refresh
-  end
-
-  specify do
-    expect { [country, other_country].map(&:destroy) }
-      .to update_index(CountriesIndex, strategy: :atomic_no_refresh)
-      .and_delete(country, other_country).only.no_refresh
-  end
-
-  context do
-    before do
-      stub_index(:countries) do
-        index_scope Country
-        root id: -> { country_code }
-      end
-    end
-
-    specify do
-      expect { [country, other_country].map(&:save!) }
-        .to update_index(CountriesIndex, strategy: :atomic_no_refresh)
-        .and_reindex('HL', 'WD').only.no_refresh
-    end
-
-    specify do
-      expect { [country, other_country].map(&:destroy) }
-        .to update_index(CountriesIndex, strategy: :atomic_no_refresh)
-        .and_delete('HL', 'WD').only.no_refresh
-    end
-
-    specify do
-      expect do
-        country.save!
-        other_country.destroy
-      end
-        .to update_index(CountriesIndex, strategy: :atomic_no_refresh)
-        .and_reindex('HL').and_delete('WD').only.no_refresh
-    end
-  end
-end