chewy 5.1.0 → 7.2.7

data/spec/chewy/search/response_spec.rb

@@ -7,28 +7,30 @@ describe Chewy::Search::Response, :orm do
     stub_model(:city)
     stub_model(:country)
 
-    stub_index(:places) do
-      define_type City do
-        field :name
-        field :rating, type: 'integer'
-      end
-
-      define_type Country do
-        field :name
-        field :rating, type: 'integer'
-      end
+    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 { PlacesIndex.import!(cities: cities, countries: countries) }
+  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(PlacesIndex).order(:rating) }
+  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: [PlacesIndex], **load_options) }
+  let(:loader) { Chewy::Search::Loader.new(indexes: [CitiesIndex, CountriesIndex], **load_options) }
   subject { described_class.new(raw_response, loader) }
 
   describe '#hits' do
@@ -59,7 +61,7 @@ describe Chewy::Search::Response, :orm do
     specify { expect(subject.max_score).to be_nil }
 
     context do
-      let(:request) { Chewy::Search::Request.new(PlacesIndex).query(range: {rating: {lte: 42}}) }
+      let(:request) { Chewy::Search::Request.new(CitiesIndex).query(range: {rating: {lte: 42}}) }
       specify { expect(subject.max_score).to eq(1.0) }
     end
   end
@@ -69,10 +71,13 @@ describe Chewy::Search::Response, :orm do
 
     context do
       let(:request) do
-        Chewy::Search::Request.new(PlacesIndex)
+        Chewy::Search::Request.new(CitiesIndex)
           .query(script: {script: {inline: 'sleep(100); true', lang: 'groovy'}})
       end
-      specify { expect(subject.took).to be > 100 }
+      specify do
+        pending
+        expect(subject.took).to be > 100
+      end
     end
   end
 
@@ -81,10 +86,13 @@ describe Chewy::Search::Response, :orm do
 
     context do
       let(:request) do
-        Chewy::Search::Request.new(PlacesIndex)
+        Chewy::Search::Request.new(CitiesIndex)
           .query(script: {script: {inline: 'sleep(100); true', lang: 'groovy'}}).timeout('10ms')
       end
-      specify { expect(subject.timed_out?).to eq(true) }
+      specify do
+        pending
+        expect(subject.timed_out?).to eq(true)
+      end
     end
   end
 
@@ -93,7 +101,7 @@ describe Chewy::Search::Response, :orm do
 
     context do
       let(:request) do
-        Chewy::Search::Request.new(PlacesIndex).suggest(
+        Chewy::Search::Request.new(CitiesIndex).suggest(
           my_suggestion: {
             text: 'city country',
             term: {
@@ -117,7 +125,9 @@ describe Chewy::Search::Response, :orm do
     specify { expect(subject.aggs).to eq({}) }
 
     context do
-      let(:request) { Chewy::Search::Request.new(PlacesIndex).aggs(avg_rating: {avg: {field: :rating}}) }
+      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
@@ -127,7 +137,7 @@ describe Chewy::Search::Response, :orm do
     specify { expect(subject.wrappers).to have(4).items }
     specify do
       expect(subject.wrappers.map(&:class).uniq)
-        .to contain_exactly(PlacesIndex::City, PlacesIndex::Country)
+        .to contain_exactly(CitiesIndex, CountriesIndex)
     end
     specify { expect(subject.wrappers.map(&:_data)).to eq(subject.hits) }
 
@@ -149,14 +159,14 @@ describe Chewy::Search::Response, :orm do
     context do
       let(:raw_response) do
         {'hits' => {'hits' => [
-          {'_index' => 'places',
+          {'_index' => 'cities',
            '_type' => 'city',
            '_id' => '1',
            '_score' => 1.3,
            '_source' => {'id' => 2, 'rating' => 0}}
         ]}}
       end
-      specify { expect(subject.wrappers.first).to be_a(PlacesIndex::City) }
+      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) }
@@ -166,14 +176,14 @@ describe Chewy::Search::Response, :orm do
     context do
       let(:raw_response) do
         {'hits' => {'hits' => [
-          {'_index' => 'places',
+          {'_index' => 'countries',
            '_type' => 'country',
            '_id' => '2',
            '_score' => 1.2,
            '_explanation' => {foo: 'bar'}}
         ]}}
       end
-      specify { expect(subject.wrappers.first).to be_a(PlacesIndex::Country) }
+      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) }

data/spec/chewy/search/scrolling_spec.rb

@@ -7,25 +7,27 @@ describe Chewy::Search::Scrolling, :orm do
     stub_model(:city)
     stub_model(:country)
 
-    stub_index(:places) do
-      define_type City do
-        field :name
-        field :rating, type: 'integer'
-      end
-
-      define_type Country do
-        field :name
-        field :rating, type: 'integer'
-      end
+    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(PlacesIndex).order(:rating) }
+  let(:request) { Chewy::Search::Request.new(CitiesIndex, CountriesIndex).order(:rating) }
 
   specify { expect(request.scroll_batches.to_a).to eq([]) }
 
   context do
-    before { PlacesIndex.import!(cities: cities, countries: countries) }
+    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}") } }
@@ -61,9 +63,9 @@ describe Chewy::Search::Scrolling, :orm do
       context do
         before { expect(Chewy.client).not_to receive(:scroll) }
         it 'respects limit and terminate_after' do
-          expect(request.terminate_after(2).limit(4).scroll_batches(batch_size: 3).map do |batch|
+          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, 1]])
+          end).to eq([[0, 2]])
         end
       end
 
@@ -103,6 +105,11 @@ describe Chewy::Search::Scrolling, :orm do
         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 = []
@@ -110,21 +117,16 @@ describe Chewy::Search::Scrolling, :orm do
             outer_payload << payload
           end
           request.scroll_batches(batch_size: 3).to_a
-
           expect(outer_payload).to match_array([
             hash_including(
-              index: PlacesIndex,
-              indexes: [PlacesIndex],
-              request: {index: ['places'], type: %w[city country], body: {sort: ['rating']}, size: 3, scroll: '1m'},
-              type: [PlacesIndex::City, PlacesIndex::Country],
-              types: [PlacesIndex::City, PlacesIndex::Country]
+              index: [CitiesIndex, CountriesIndex],
+              indexes: [CitiesIndex, CountriesIndex],
+              request: {index: %w[cities countries], body: {sort: ['rating']}, size: 3, scroll: '1m'}
             ),
             hash_including(
-              index: PlacesIndex,
-              indexes: [PlacesIndex],
-              request: {scroll: '1m', scroll_id: an_instance_of(String)},
-              type: [PlacesIndex::City, PlacesIndex::Country],
-              types: [PlacesIndex::City, PlacesIndex::Country]
+              index: [CitiesIndex, CountriesIndex],
+              indexes: [CitiesIndex, CountriesIndex],
+              request: {scroll: '1m', scroll_id: an_instance_of(String)}
             )
           ])
         end
@@ -149,7 +151,7 @@ describe Chewy::Search::Scrolling, :orm do
       end
       specify do
         expect(request.scroll_wrappers(batch_size: 2).map(&:class).uniq)
-          .to eq([PlacesIndex::City, PlacesIndex::Country])
+          .to eq([CitiesIndex, CountriesIndex])
       end
     end
 

data/spec/chewy/search_spec.rb

@@ -4,48 +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::Search::Request) }
-    specify { expect(product.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) }
-      specify { expect(product.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: %w[product product2]))
+      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
@@ -53,7 +39,7 @@ describe Chewy::Search do
       stub_model(:city)
       stub_model(:country)
 
-      stub_index(:places) do
+      stub_index(:cities) do
         def self.by_rating(value)
           filter { match rating: value }
         end
@@ -62,56 +48,80 @@ describe Chewy::Search do
           filter { match name: "Name#{index}" }
         end
 
-        define_type City do
-          def self.by_rating
-            filter { match rating: yield }
-          end
+        def self.by_rating_with_kwargs(value, options:) # rubocop:disable Lint/UnusedMethodArgument
+          filter { match rating: value }
+        end
 
-          def self.by_index(index)
-            filter { match name: "Name#{index}" }
-          end
+        index_scope City
+        field :name, type: 'keyword'
+        field :rating, type: :integer
+      end
 
-          field :name, KEYWORD_FIELD
-          field :rating, type: :integer
+      stub_index(:countries) do
+        def self.by_rating(value)
+          filter { match rating: value }
         end
 
-        define_type Country do
-          field :name, KEYWORD_FIELD
-          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) { 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 { 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(2).map(&:rating)).to eq([1]) }
-    specify { expect(PlacesIndex.by_rating(1).by_name(2).map(&:class)).to eq([PlacesIndex::City]) }
-    specify { expect(PlacesIndex.by_name(3).map(&:rating)).to eq([2, 1]) }
-    specify { expect(PlacesIndex.by_name(3).map(&:class)).to eq([PlacesIndex::City, PlacesIndex::Country]) }
-    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(3).map(&:rating)).to eq([2]) }
-    specify { expect(PlacesIndex::City.by_rating { 2 }.by_name(3).map(&:class)).to eq([PlacesIndex::City]) }
-    specify { expect(PlacesIndex::City.by_name(3).map(&:rating)).to eq([2]) }
-    specify { expect(PlacesIndex::City.by_index(3).map(&:rating)).to eq([2]) }
-    specify { expect(PlacesIndex::City.order(:name).by_name(3).map(&:rating)).to eq([2]) }
-    specify { expect(PlacesIndex::City.order(:name).by_index(3).map(&:rating)).to eq([2]) }
-    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(5).map(&:rating)).to eq([3]) }
-    specify { expect(PlacesIndex::Country.by_rating(3).by_name(5).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]) }
+    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

@@ -9,11 +9,11 @@ describe Chewy::Stash::Journal, :orm do
 
   before do
     stub_model(:city)
-    stub_index(:places) do
-      define_type City
-      define_type :country
+    stub_index(:cities) do
+      index_scope City
     end
-    stub_index(:users) { define_type :user }
+    stub_index(:countries)
+    stub_index(:users)
     stub_index(:borogoves)
   end
 
@@ -21,12 +21,12 @@ describe Chewy::Stash::Journal, :orm do
   after { Timecop.return }
 
   before do
-    PlacesIndex::City.import!(City.new(id: 1, name: 'City'), journal: true)
+    CitiesIndex.import!(City.new(id: 1, name: 'City'), journal: true)
     Timecop.travel(Time.now + 1.minute) do
-      PlacesIndex::Country.import!([id: 2, name: 'Country'], journal: true)
+      CountriesIndex.import!([id: 2, name: 'Country'], journal: true)
     end
     Timecop.travel(Time.now + 2.minutes) do
-      UsersIndex::User.import!([id: 3, name: 'User'], journal: true)
+      UsersIndex.import!([id: 3, name: 'User'], journal: true)
     end
   end
 
@@ -49,11 +49,11 @@ describe Chewy::Stash::Journal, :orm do
         .to contain_exactly([{'id' => 3, 'name' => 'User'}])
     end
     specify do
-      expect(described_class.entries(Time.now - 30.seconds, only: [PlacesIndex::City, UsersIndex]).map(&:references))
+      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: [PlacesIndex::City, UsersIndex]).map(&:references))
+      expect(described_class.entries(Time.now + 30.seconds, only: [CitiesIndex, UsersIndex]).map(&:references))
         .to contain_exactly([{'id' => 3, 'name' => 'User'}])
     end
     specify do
@@ -68,28 +68,18 @@ describe Chewy::Stash::Journal, :orm do
     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: [PlacesIndex::City, UsersIndex]))).to eq(2) }
+    specify { expect(fetch_deleted_number(described_class.clean(only: [CitiesIndex, UsersIndex]))).to eq(2) }
 
-    specify { expect(fetch_deleted_number(described_class.clean(Time.now + 30.seconds, only: PlacesIndex::Country))).to eq(0) }
-    specify { expect(fetch_deleted_number(described_class.clean(Time.now + 30.seconds, only: PlacesIndex::City))).to eq(1) }
+    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 { expect(described_class.for(PlacesIndex).map(&:type_name)).to contain_exactly('city', 'country') }
-    specify { expect(described_class.for(PlacesIndex::City, UsersIndex).map(&:index_name)).to contain_exactly('places', 'users') }
-  end
-
-  describe '#type' do
-    let(:index_name) { 'users' }
-    let(:type_name) { 'city' }
-    subject { described_class::Journal.new('index_name' => index_name, 'type_name' => type_name).type }
-
-    specify { expect { subject }.to raise_error(Chewy::UnderivableType) }
-
-    context do
-      let(:index_name) { 'places' }
-      it { is_expected.to eq(PlacesIndex::City) }
+    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

@@ -2,7 +2,12 @@ require 'spec_helper'
 
 if defined?(::ActiveJob)
   describe Chewy::Strategy::ActiveJob do
-    around { |example| Chewy.strategy(:bypass) { example.run } }
+    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
@@ -14,11 +19,11 @@ if defined?(::ActiveJob)
 
     before do
       stub_model(:city) do
-        update_index('cities#city') { self }
+        update_index('cities') { self }
       end
 
       stub_index(:cities) do
-        define_type City
+        index_scope City
       end
     end
 
@@ -27,7 +32,7 @@ if defined?(::ActiveJob)
 
     specify do
       expect { [city, other_city].map(&:save!) }
-        .not_to update_index(CitiesIndex::City, strategy: :active_job)
+        .not_to update_index(CitiesIndex, strategy: :active_job)
     end
 
     specify do
@@ -36,25 +41,33 @@ if defined?(::ActiveJob)
       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('chewy')
+      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::City, strategy: :active_job)
+        .to update_index(CitiesIndex, strategy: :active_job)
         .and_reindex(city, other_city).only
     end
 
     specify do
-      expect(CitiesIndex::City).to receive(:import!).with([city.id, other_city.id], suffix: '201601')
-      Chewy::Strategy::ActiveJob::Worker.new.perform('CitiesIndex::City', [city.id, other_city.id], suffix: '201601')
+      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::City).to receive(:import!).with([city.id, other_city.id], suffix: '201601', refresh: false)
-      Chewy::Strategy::ActiveJob::Worker.new.perform('CitiesIndex::City', [city.id, other_city.id], suffix: '201601')
+      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

@@ -0,0 +1,60 @@
+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