chewy 0.8.4 → 5.1.0

data/spec/chewy/index_spec.rb

@@ -18,8 +18,8 @@ describe Chewy::Index do
       end
     end
 
-    let!(:cities) { 2.times.map { |i| City.create! id: i + 1 } }
-    let!(:countries) { 2.times.map { |i| Country.create! id: i + 1 } }
+    let!(:cities) { Array.new(2) { |i| City.create! id: i + 1 } }
+    let!(:countries) { Array.new(2) { |i| Country.create! id: i + 1 } }
 
     specify do
       expect { PlacesIndex.import }.to update_index(PlacesIndex::City).and_reindex(cities)
@@ -61,16 +61,28 @@ describe Chewy::Index do
     specify { expect(stub_const('DeveloperIndex', Class.new(Chewy::Index)).index_name).to eq('developer') }
     specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name).to eq('developers') }
 
+    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name(suffix: '')).to eq('developers') }
+    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name(suffix: '2013')).to eq('developers_2013') }
+    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name(prefix: '')).to eq('developers') }
+    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name(prefix: 'test')).to eq('test_developers') }
+
     context do
       before { allow(Chewy).to receive_messages(configuration: {prefix: 'testing'}) }
       specify { expect(DummiesIndex.index_name).to eq('testing_dummies') }
       specify { expect(stub_index(:dummies) { index_name :users }.index_name).to eq('testing_users') }
+      specify { expect(stub_index(:dummies) { index_name :users }.index_name(prefix: '')).to eq('users') }
     end
   end
 
-  describe '.default_prefix' do
+  describe '.derivable_name' do
+    specify { expect(Class.new(Chewy::Index).derivable_name).to be_nil }
+    specify { expect(stub_index(:places).derivable_name).to eq('places') }
+    specify { expect(stub_index('namespace/places').derivable_name).to eq('namespace/places') }
+  end
+
+  describe '.prefix' do
     before { allow(Chewy).to receive_messages(configuration: {prefix: 'testing'}) }
-    specify { expect(Class.new(Chewy::Index).default_prefix).to eq('testing') }
+    specify { expect(Class.new(Chewy::Index).prefix).to eq('testing') }
   end
 
   describe '.define_type' do
@@ -92,40 +104,39 @@ describe Chewy::Index do
       before { stub_class('City::District', City) }
 
       specify do
-        expect {
+        expect do
           Kernel.eval <<-DUMMY_CITY_INDEX
             class DummyCityIndex < Chewy::Index
               define_type City
               define_type City::District
             end
           DUMMY_CITY_INDEX
-        }.not_to raise_error
+        end.not_to raise_error
       end
 
       specify do
-        expect {
+        expect do
           Kernel.eval <<-DUMMY_CITY_INDEX
             class DummyCityIndex2 < Chewy::Index
               define_type City
               define_type City::Nothing
             end
           DUMMY_CITY_INDEX
-        }.to raise_error(NameError)
+        end.to raise_error(NameError)
       end
     end
 
-    context 'type methods should be deprecated and can\'t redefine existion ones' do
+    context 'type methods should be deprecated and can\'t redefine existing ones' do
       before do
         stub_index(:places) do
-          def self.city
-          end
+          def self.city; end
           define_type :city
           define_type :country
         end
       end
 
       specify { expect(PlacesIndex.city).to be_nil }
-      specify { expect(PlacesIndex.country).to be < Chewy::Type }
+      specify { expect(PlacesIndex::Country).to be < Chewy::Type }
     end
   end
 
@@ -136,19 +147,24 @@ describe Chewy::Index do
     specify { expect(DummiesIndex.type_hash['dummy'].type_name).to eq('dummy') }
   end
 
+  describe '.type' do
+    specify { expect(DummiesIndex.type('dummy')).to eq(DummiesIndex::Dummy) }
+    specify { expect { DummiesIndex.type('not-the-dummy') }.to raise_error(Chewy::UndefinedType) }
+  end
+
   specify { expect(DummiesIndex.type_names).to eq(DummiesIndex.type_hash.keys) }
 
   describe '.types' do
     specify { expect(DummiesIndex.types).to eq(DummiesIndex.type_hash.values) }
-    specify { expect(DummiesIndex.types(:dummy)).to be_a Chewy::Query }
-    specify { expect(DummiesIndex.types(:user)).to be_a Chewy::Query }
+    specify { expect(DummiesIndex.types(:dummy)).to be_a Chewy::Search::Request }
+    specify { expect(DummiesIndex.types(:user)).to be_a Chewy::Search::Request }
   end
 
   describe '.settings' do
     before do
       allow(Chewy).to receive_messages(config: Chewy::Config.send(:new))
 
-      Chewy.analyzer :name, filter: ['lowercase', 'icu_folding', 'names_nysiis']
+      Chewy.analyzer :name, filter: %w[lowercase icu_folding names_nysiis]
       Chewy.analyzer :phone, tokenizer: 'ngram', char_filter: ['phone']
       Chewy.tokenizer :ngram, type: 'nGram', min_gram: 3, max_gram: 3
       Chewy.char_filter :phone, type: 'pattern_replace', pattern: '[^\d]', replacement: ''
@@ -157,85 +173,165 @@ describe Chewy::Index do
 
     let(:documents) { stub_index(:documents) { settings analysis: {analyzer: [:name, :phone, {sorted: {option: :baz}}]} } }
 
-    specify { expect { documents.settings_hash }.to_not change(documents._settings, :inspect)  }
-    specify { expect(documents.settings_hash).to eq({settings: {analysis: {
-      analyzer: {name: {filter: ['lowercase', 'icu_folding', 'names_nysiis']},
-                 phone: {tokenizer: 'ngram', char_filter: ['phone']},
-                 sorted: {option: :baz}},
-      tokenizer: {ngram: {type: 'nGram', min_gram: 3, max_gram: 3}},
-      char_filter: {phone: {type: 'pattern_replace', pattern: '[^\d]', replacement: ''}},
-      filter: {names_nysiis: {type: 'phonetic', encoder: 'nysiis', replace: false}}
-    }}}) }
+    specify { expect { documents.settings_hash }.to_not change(documents._settings, :inspect) }
+    specify do
+      expect(documents.settings_hash).to eq(settings: {analysis: {
+        analyzer: {name: {filter: %w[lowercase icu_folding names_nysiis]},
+                   phone: {tokenizer: 'ngram', char_filter: ['phone']},
+                   sorted: {option: :baz}},
+        tokenizer: {ngram: {type: 'nGram', min_gram: 3, max_gram: 3}},
+        char_filter: {phone: {type: 'pattern_replace', pattern: '[^\d]', replacement: ''}},
+        filter: {names_nysiis: {type: 'phonetic', encoder: 'nysiis', replace: false}}
+      }})
+    end
   end
 
   describe '.scopes' do
     before do
       stub_index(:places) do
-        def self.by_rating
-        end
+        def self.by_rating; end
 
-        def self.by_name
+        def self.colors(*colors)
+          filter(terms: {colors: colors.flatten(1).map(&:to_s)})
         end
 
         define_type :city do
-          def self.by_id
-          end
+          def self.by_id; end
+          field :colors
         end
       end
     end
 
     specify { expect(described_class.scopes).to eq([]) }
-    specify { expect(PlacesIndex.scopes).to match_array([:by_rating, :by_name]) }
-  end
+    specify { expect(PlacesIndex.scopes).to match_array(%i[by_rating colors]) }
+
+    context do
+      before do
+        Chewy.massacre
+        PlacesIndex::City.import!(
+          double(colors: ['red']),
+          double(colors: %w[red green]),
+          double(colors: %w[green yellow])
+        )
+      end
 
-  describe '.build_index_name' do
-    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).build_index_name(suffix: '')).to eq('developers') }
-    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).build_index_name(suffix: '2013')).to eq('developers_2013') }
-    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).build_index_name(prefix: '')).to eq('developers') }
-    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).build_index_name(prefix: 'test')).to eq('test_developers') }
-    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).build_index_name(:users, prefix: 'test', suffix: '2013')).to eq('test_users_2013') }
+      specify do
+        # This `blank?`` call is for the messed scopes bug reproduction. See #573
+        PlacesIndex::City.blank?
+        expect(PlacesIndex.colors(:green).map(&:colors))
+          .to contain_exactly(%w[red green], %w[green yellow])
+      end
+
+      specify do
+        # This `blank?` call is for the messed scopes bug reproduction. See #573
+        PlacesIndex::City.blank?
+        expect(PlacesIndex::City.colors(:green).map(&:colors))
+          .to contain_exactly(%w[red green], %w[green yellow])
+      end
+    end
   end
 
   describe '.settings_hash' do
     before { allow(Chewy).to receive_messages(config: Chewy::Config.send(:new)) }
 
     specify { expect(stub_index(:documents).settings_hash).to eq({}) }
-    specify { expect(stub_index(:documents) { settings number_of_shards: 1 }.settings_hash).to eq({settings: {number_of_shards: 1}}) }
+    specify { expect(stub_index(:documents) { settings number_of_shards: 1 }.settings_hash).to eq(settings: {number_of_shards: 1}) }
   end
 
   describe '.mappings_hash' do
     specify { expect(stub_index(:documents).mappings_hash).to eq({}) }
     specify { expect(stub_index(:documents) { define_type :document }.mappings_hash).to eq({}) }
-    specify { expect(stub_index(:documents) do
-      define_type :document do
-        field :name, type: 'string'
-      end
-    end.mappings_hash).to eq({mappings: {document: {properties: {name: {type: 'string'}}}}}) }
-    specify { expect(stub_index(:documents) do
-      define_type :document do
-        field :name, type: 'string'
-      end
-      define_type :document2 do
-        field :name, type: 'string'
-      end
-    end.mappings_hash[:mappings].keys).to match_array([:document, :document2]) }
+    specify do
+      expect(stub_index(:documents) do
+               define_type :document do
+                 field :date, type: 'date'
+               end
+             end.mappings_hash).to eq(mappings: {document: {properties: {date: {type: 'date'}}}})
+    end
+    specify do
+      expect(stub_index(:documents) do
+               define_type :document do
+                 field :name
+               end
+               define_type :document2 do
+                 field :name
+               end
+             end.mappings_hash[:mappings].keys).to match_array(%i[document document2])
+    end
   end
 
-  describe '.index_params' do
+  describe '.specification_hash' do
     before { allow(Chewy).to receive_messages(config: Chewy::Config.send(:new)) }
 
-    specify { expect(stub_index(:documents).index_params).to eq({}) }
-    specify { expect(stub_index(:documents) { settings number_of_shards: 1 }.index_params.keys).to eq([:settings]) }
-    specify { expect(stub_index(:documents) do
-      define_type :document do
-        field :name, type: 'string'
+    specify { expect(stub_index(:documents).specification_hash).to eq({}) }
+    specify { expect(stub_index(:documents) { settings number_of_shards: 1 }.specification_hash.keys).to eq([:settings]) }
+    specify do
+      expect(stub_index(:documents) do
+               define_type :document do
+                 field :name
+               end
+             end.specification_hash.keys).to eq([:mappings])
+    end
+    specify do
+      expect(stub_index(:documents) do
+               settings number_of_shards: 1
+               define_type :document do
+                 field :name
+               end
+             end.specification_hash.keys).to match_array(%i[mappings settings])
+    end
+  end
+
+  describe '.specification' do
+    subject { stub_index(:documents) }
+    specify { expect(subject.specification).to be_a(Chewy::Index::Specification) }
+    specify { expect(subject.specification).to equal(subject.specification) }
+  end
+
+  describe '.default_prefix' do
+    before { allow(Chewy).to receive_messages(configuration: {prefix: 'testing'}) }
+
+    context do
+      before { expect(ActiveSupport::Deprecation).to receive(:warn).once }
+      specify { expect(DummiesIndex.default_prefix).to eq('testing') }
+    end
+
+    context do
+      before do
+        DummiesIndex.class_eval do
+          def self.default_prefix
+            'borogoves'
+          end
+        end
       end
-    end.index_params.keys).to eq([:mappings]) }
-    specify { expect(stub_index(:documents) do
-      settings number_of_shards: 1
-      define_type :document do
-        field :name, type: 'string'
+
+      before { expect(ActiveSupport::Deprecation).to receive(:warn).once }
+      specify { expect(DummiesIndex.index_name).to eq('borogoves_dummies') }
+    end
+  end
+
+  context 'index call inside index', :orm do
+    before do
+      stub_index(:cities) do
+        define_type :city do
+          field :country_name, value: (lambda do |city|
+            CountriesIndex::Country.filter(term: {_id: city.country_id}).first.name
+          end)
+        end
       end
-    end.index_params.keys).to match_array([:mappings, :settings]) }
+
+      stub_index(:countries) do
+        define_type :country do
+          field :name
+        end
+      end
+
+      CountriesIndex::Country.import!(double(id: 1, name: 'Country'))
+    end
+
+    specify do
+      expect { CitiesIndex::City.import!(double(country_id: 1)) }
+        .to update_index(CitiesIndex::City).and_reindex(country_name: 'Country')
+    end
   end
 end

data/spec/chewy/journal_spec.rb

@@ -0,0 +1,268 @@
+require 'spec_helper'
+
+describe Chewy::Journal do
+  context 'journaling', :orm do
+    ['', 'namespace/'].each do |namespace|
+      context namespace.present? ? 'with namespace' : 'without namespace' do
+        before do
+          stub_model(:city) do
+            update_index "#{namespace}places#city", :self
+          end
+          stub_model(:country) do
+            update_index "#{namespace}places#country", :self
+          end
+
+          stub_index("#{namespace}places") do
+            define_type City do
+              default_import_options journal: true
+            end
+            define_type Country do
+              default_import_options journal: true
+            end
+          end
+
+          Chewy.massacre
+          Chewy.settings[:prefix] = 'some_prefix'
+          Timecop.freeze(time)
+        end
+
+        after do
+          Chewy.settings[:prefix] = nil
+          Timecop.return
+        end
+
+        let(:time) { Time.now }
+        let(:import_time) { time + 1 }
+        let(:update_time) { time + 2 }
+        let(:destroy_time) { time + 3 }
+
+        def timestamp(time)
+          time.to_i
+        end
+
+        specify do
+          places_index = namespace.present? ? Namespace::PlacesIndex : PlacesIndex
+          Chewy.strategy(:urgent) do
+            cities = Array.new(2) { |i| City.create!(id: i + 1) }
+            countries = Array.new(2) { |i| Country.create!(id: i + 1) }
+            Country.create!(id: 3)
+
+            Timecop.freeze(import_time)
+
+            places_index.import
+
+            expect(Chewy::Stash::Journal.exists?).to eq true
+
+            Timecop.freeze(update_time)
+            cities.first.update_attributes!(name: 'Supername')
+
+            Timecop.freeze(destroy_time)
+            countries.last.destroy
+
+            journal_entries = Chewy::Stash::Journal.order(:created_at).hits.map { |r| r['_source'] }
+            expected_journal = [
+              {
+                'index_name' => "#{namespace}places",
+                'type_name' => 'city',
+                'action' => 'index',
+                'references' => ['1'].map(&Base64.method(:encode64)),
+                'created_at' => time.utc.as_json
+              },
+              {
+                'index_name' => "#{namespace}places",
+                'type_name' => 'city',
+                'action' => 'index',
+                'references' => ['2'].map(&Base64.method(:encode64)),
+                'created_at' => time.utc.as_json
+              },
+              {
+                'index_name' => "#{namespace}places",
+                'type_name' => 'country',
+                'action' => 'index',
+                'references' => ['1'].map(&Base64.method(:encode64)),
+                'created_at' => time.utc.as_json
+              },
+              {
+                'index_name' => "#{namespace}places",
+                'type_name' => 'country',
+                'action' => 'index',
+                'references' => ['2'].map(&Base64.method(:encode64)),
+                'created_at' => time.utc.as_json
+              },
+              {
+                'index_name' => "#{namespace}places",
+                'type_name' => 'country',
+                'action' => 'index',
+                'references' => ['3'].map(&Base64.method(:encode64)),
+                'created_at' => time.utc.as_json
+              },
+              {
+                'index_name' => "#{namespace}places",
+                'type_name' => 'city',
+                'action' => 'index',
+                'references' => %w[1 2].map(&Base64.method(:encode64)),
+                'created_at' => import_time.utc.as_json
+              },
+              {
+                'index_name' => "#{namespace}places",
+                'type_name' => 'country',
+                'action' => 'index',
+                'references' => %w[1 2 3].map(&Base64.method(:encode64)),
+                'created_at' => import_time.utc.as_json
+              },
+              {
+                'index_name' => "#{namespace}places",
+                'type_name' => 'city',
+                'action' => 'index',
+                'references' => ['1'].map(&Base64.method(:encode64)),
+                'created_at' => update_time.utc.as_json
+              },
+              {
+                'index_name' => "#{namespace}places",
+                'type_name' => 'country',
+                'action' => 'delete',
+                'references' => ['2'].map(&Base64.method(:encode64)),
+                'created_at' => destroy_time.utc.as_json
+              }
+            ]
+
+            expect(Chewy::Stash::Journal.count).to eq 9
+            expect(journal_entries).to eq expected_journal
+
+            journal_entries = Chewy::Stash::Journal.entries(import_time - 1)
+            expect(journal_entries.size).to eq 4
+
+            # simulate lost data
+            Chewy.client.delete(index: "#{Chewy.settings[:prefix]}_places", type: 'city', id: 1, refresh: true)
+            expect(places_index::City.count).to eq 1
+
+            described_class.new.apply(time)
+            expect(places_index::City.count).to eq 2
+
+            clean_response = described_class.new.clean(import_time)
+            expect(clean_response['deleted'] || clean_response['_indices']['_all']['deleted']).to eq 7
+            Chewy.client.indices.refresh
+            expect(Chewy::Stash::Journal.count).to eq 2
+
+            Timecop.return
+          end
+        end
+      end
+    end
+  end
+
+  context do
+    before { Chewy.massacre }
+    before do
+      stub_model(:city) do
+        update_index 'cities', :self
+      end
+      stub_model(:country) do
+        update_index 'countries', :self
+      end
+
+      stub_index(:cities) do
+        define_type City do
+          default_import_options journal: true
+        end
+      end
+      stub_index(:countries) do
+        define_type Country do
+          default_import_options journal: true
+        end
+      end
+    end
+
+    describe '#apply' do
+      specify { expect(described_class.new(CitiesIndex).apply(2.minutes.ago)).to eq(0) }
+
+      context 'with an index filter' do
+        let(:time) { Time.now }
+
+        before { Timecop.freeze(time) }
+        after { Timecop.return }
+
+        specify do
+          Chewy.strategy(:urgent) do
+            Array.new(2) { |i| City.create!(id: i + 1) }
+            Array.new(2) { |i| Country.create!(id: i + 1) }
+
+            # simulate lost data
+            Chewy.client.delete(index: 'cities', type: 'city', id: 1, refresh: true)
+            Chewy.client.delete(index: 'countries', type: 'country', id: 1, refresh: true)
+            expect(CitiesIndex.all.to_a.length).to eq 1
+            expect(CountriesIndex.all.to_a.length).to eq 1
+
+            # Replay on specific index
+            expect(described_class.new(CitiesIndex).apply(time)).to eq(2)
+            expect(CitiesIndex.all.to_a.length).to eq 2
+            expect(CountriesIndex.all.to_a.length).to eq 1
+
+            # Replay on both
+            Chewy.client.delete(index: 'cities', type: 'city', id: 1, refresh: true)
+            expect(CitiesIndex.all.to_a.length).to eq 1
+            expect(described_class.new(CitiesIndex, CountriesIndex).apply(time)).to eq(4)
+            expect(CitiesIndex.all.to_a.length).to eq 2
+            expect(CountriesIndex.all.to_a.length).to eq 2
+          end
+        end
+      end
+
+      context 'retries' do
+        let(:time) { Time.now.to_i }
+        before do
+          Timecop.freeze
+          Chewy.strategy(:urgent)
+          City.create!(id: 1)
+        end
+
+        after do
+          Chewy.strategy.pop
+          Timecop.return
+        end
+
+        specify 'journal was cleaned after the first call' do
+          expect(Chewy::Stash::Journal).to receive(:entries).exactly(2).and_call_original
+          expect(described_class.new.apply(time)).to eq(1)
+        end
+
+        context 'endless journal' do
+          let(:count_of_checks) { 10 } # default
+          let!(:journal_entries) do
+            record = Chewy::Stash::Journal.entries(time).first
+            Array.new(count_of_checks) do |i|
+              Chewy::Stash::Journal::Journal.new(
+                record.attributes.merge(
+                  'created_at' => time.to_i + i,
+                  'references' => [i.to_s]
+                )
+              )
+            end
+          end
+
+          specify '10 retries by default' do
+            expect(Chewy::Stash::Journal)
+              .to receive(:entries).exactly(count_of_checks) { [journal_entries.shift].compact }
+            expect(described_class.new.apply(time)).to eq(10)
+          end
+
+          specify 'with :once parameter set' do
+            expect(Chewy::Stash::Journal)
+              .to receive(:entries).exactly(1) { [journal_entries.shift].compact }
+            expect(described_class.new.apply(time, retries: 1)).to eq(1)
+          end
+
+          context 'with retries parameter set' do
+            let(:retries) { 5 }
+
+            specify do
+              expect(Chewy::Stash::Journal)
+                .to receive(:entries).exactly(retries) { [journal_entries.shift].compact }
+              expect(described_class.new.apply(time, retries: retries)).to eq(5)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/chewy/minitest/helpers_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+require 'chewy/minitest'
+
+describe :minitest_helper do
+  class << self
+    alias_method :teardown, :after
+  end
+
+  def assert_includes(haystack, needle, _comment)
+    expect(haystack).to include(needle)
+  end
+
+  include ::Chewy::Minitest::Helpers
+
+  before do
+    Chewy.massacre
+  end
+
+  before do
+    stub_index(:dummies) do
+      define_type :dummy do
+        root value: ->(_o) { {} }
+      end
+    end
+  end
+
+  context 'assert_indexes' do
+    specify 'doesn\'t fail when index updates correctly' do
+      expect do
+        assert_indexes DummiesIndex::Dummy do
+          DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
+        end
+      end.to_not raise_error
+    end
+
+    specify 'fails when index doesn\'t update' do
+      expect do
+        assert_indexes DummiesIndex::Dummy do
+        end
+      end.to raise_error(RSpec::Expectations::ExpectationNotMetError)
+    end
+
+    specify 'SearchIndexReceiver catches the indexes' do
+      receiver = assert_indexes DummiesIndex::Dummy do
+        DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
+      end
+
+      expect(receiver).to be_a(SearchIndexReceiver)
+
+      expect(
+        receiver.indexes_for(DummiesIndex::Dummy)
+                .map { |index| index[:_id] }
+      ).to match_array([41, 42])
+    end
+
+    specify 'Real index is bypassed when asserting' do
+      expect(DummiesIndex::Dummy).not_to receive(:bulk)
+
+      assert_indexes DummiesIndex::Dummy do
+        DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
+      end
+    end
+
+    specify 'Real index is allowed when asserting' do
+      expect(DummiesIndex::Dummy).to receive(:bulk)
+
+      assert_indexes DummiesIndex::Dummy, bypass_actual_index: false do
+        DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
+      end
+    end
+  end
+
+  context 'run_indexing' do
+    specify 'pushes onto the chewy strategy stack' do
+      Chewy.strategy :bypass do
+        run_indexing do
+          expect(Chewy.strategy.current.name).to be(:atomic)
+        end
+      end
+    end
+
+    specify 'allows tester to specify the strategy' do
+      Chewy.strategy :atomic do
+        run_indexing strategy: :bypass do
+          expect(Chewy.strategy.current.name).to be(:bypass)
+        end
+      end
+    end
+  end
+end