chewy 0.8.4 → 5.1.0

data/spec/chewy/search/response_spec.rb

@@ -0,0 +1,192 @@
+require 'spec_helper'
+
+describe Chewy::Search::Response, :orm do
+  before { Chewy.massacre }
+
+  before 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
+    end
+  end
+
+  before { PlacesIndex.import!(cities: cities, countries: countries) }
+
+  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(:raw_response) { request.send(:perform) }
+  let(:load_options) { {} }
+  let(:loader) { Chewy::Search::Loader.new(indexes: [PlacesIndex], **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(PlacesIndex).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(PlacesIndex)
+          .query(script: {script: {inline: 'sleep(100); true', lang: 'groovy'}})
+      end
+      specify { expect(subject.took).to be > 100 }
+    end
+  end
+
+  describe '#timed_out?' do
+    specify { expect(subject.timed_out?).to eq(false) }
+
+    context do
+      let(:request) do
+        Chewy::Search::Request.new(PlacesIndex)
+          .query(script: {script: {inline: 'sleep(100); true', lang: 'groovy'}}).timeout('10ms')
+      end
+      specify { expect(subject.timed_out?).to eq(true) }
+    end
+  end
+
+  describe '#suggest' do
+    specify { expect(subject.suggest).to eq({}) }
+
+    context do
+      let(:request) do
+        Chewy::Search::Request.new(PlacesIndex).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) { Chewy::Search::Request.new(PlacesIndex).aggs(avg_rating: {avg: {field: :rating}}) }
+      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(PlacesIndex::City, PlacesIndex::Country)
+    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' => 'places',
+           '_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.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' => 'places',
+           '_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.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,169 @@
+require 'spec_helper'
+
+describe Chewy::Search::Scrolling, :orm do
+  before { Chewy.massacre }
+
+  before 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
+    end
+  end
+
+  let(:request) { Chewy::Search::Request.new(PlacesIndex).order(:rating) }
+
+  specify { expect(request.scroll_batches.to_a).to eq([]) }
+
+  context do
+    before { PlacesIndex.import!(cities: cities, countries: countries) }
+
+    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(2).limit(4).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) }
+        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
+
+      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: 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]
+            ),
+            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]
+            )
+          ])
+        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([PlacesIndex::City, PlacesIndex::Country])
+      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

@@ -13,8 +13,15 @@ describe Chewy::Search do
   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) }
+    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
@@ -31,7 +38,7 @@ describe Chewy::Search do
     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'], type: %w[product product2]))
       ProductsIndex.search_string('hello')
     end
 
@@ -48,52 +55,62 @@ describe Chewy::Search do
 
       stub_index(:places) 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
 
         define_type City do
           def self.by_rating
-            filter { rating == yield }
+            filter { match rating: yield }
+          end
+
+          def self.by_index(index)
+            filter { match name: "Name#{index}" }
           end
 
-          field :name, index: 'not_analyzed'
+          field :name, KEYWORD_FIELD
           field :rating, type: :integer
         end
 
         define_type Country do
-          field :name, index: 'not_analyzed'
+          field :name, KEYWORD_FIELD
           field :rating, type: :integer
         end
       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}" } }
+    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(1).map(&:rating)).to eq([1]) }
-    specify { expect(PlacesIndex.by_rating(1).by_name(1).map(&:class)).to eq([PlacesIndex::City]) }
+    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(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::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(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.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]) }
   end

data/spec/chewy/stash_spec.rb

@@ -0,0 +1,95 @@
+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(:places) do
+      define_type City
+      define_type :country
+    end
+    stub_index(:users) { define_type :user }
+    stub_index(:borogoves)
+  end
+
+  before { Timecop.freeze }
+  after { Timecop.return }
+
+  before do
+    PlacesIndex::City.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)
+    end
+    Timecop.travel(Time.now + 2.minutes) do
+      UsersIndex::User.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: [PlacesIndex::City, 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))
+        .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: [PlacesIndex::City, 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) }
+  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) }
+    end
+  end
+end

data/spec/chewy/strategy/active_job_spec.rb

@@ -47,8 +47,14 @@ if defined?(::ActiveJob)
     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::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')
+    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')
     end
   end
 end

data/spec/chewy/strategy/atomic_spec.rb

@@ -51,7 +51,10 @@ describe Chewy::Strategy::Atomic, :orm do
     end
 
     specify do
-      expect { country.save!; other_country.destroy }
+      expect do
+        country.save!
+        other_country.destroy
+      end
         .to update_index(CountriesIndex::Country, strategy: :atomic)
         .and_reindex('HL').and_delete('WD').only
     end

data/spec/chewy/strategy/resque_spec.rb

@@ -33,8 +33,14 @@ if defined?(::Resque)
     end
 
     specify do
-      expect(CitiesIndex::City).to receive(:import!).with([city.id, other_city.id], {suffix: '201601'})
-      Chewy::Strategy::Resque::Worker.perform("CitiesIndex::City", [city.id, other_city.id], suffix: '201601')
+      expect(CitiesIndex::City).to receive(:import!).with([city.id, other_city.id], suffix: '201601')
+      Chewy::Strategy::Resque::Worker.perform('CitiesIndex::City', [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::Resque::Worker.perform('CitiesIndex::City', [city.id, other_city.id], suffix: '201601')
     end
   end
 end

data/spec/chewy/strategy/shoryuken_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+if defined?(::Shoryuken)
+  require 'aws-sdk-sqs'
+
+  describe Chewy::Strategy::Shoryuken do
+    around { |example| Chewy.strategy(:bypass) { example.run } }
+    before { ::Shoryuken.groups.clear }
+    before do
+      stub_model(:city) do
+        update_index('cities#city') { self }
+      end
+
+      stub_index(:cities) do
+        define_type City
+      end
+    end
+
+    let(:city) { City.create!(name: 'hello') }
+    let(:other_city) { City.create!(name: 'world') }
+    let(:queue) { instance_double(::Shoryuken::Queue) }
+
+    before do
+      allow(::Shoryuken::Queue).to receive(:new).and_return(queue)
+      allow(queue).to receive(:send_message).and_return(nil)
+    end
+
+    specify do
+      expect { [city, other_city].map(&:save!) }
+        .not_to update_index(CitiesIndex::City, strategy: :shoryuken)
+    end
+
+    specify do
+      Chewy.settings[:shoryuken] = {queue: 'low'}
+      expect(Chewy::Strategy::Shoryuken::Worker).to receive(:perform_async)
+        .with(hash_including(type: 'CitiesIndex::City', ids: [city.id, other_city.id]), hash_including(queue: 'low'))
+      Chewy.strategy(:shoryuken) do
+        [city, other_city].map(&:save!)
+      end
+    end
+
+    let(:body) do
+      {
+        'type' => 'CitiesIndex::City',
+        'ids' => [city.id, other_city.id],
+        'options' => {'suffix' => '201601'}
+      }
+    end
+    let(:sqs_msg) do
+      double id: 'fc754df7-9cc2-4c41-96ca-5996a44b771e',
+             body: body,
+             delete: nil
+    end
+
+    specify do
+      expect(CitiesIndex::City).to receive(:import!).with([city.id, other_city.id], suffix: '201601')
+      Chewy::Strategy::Shoryuken::Worker.new.perform(sqs_msg, body)
+    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::Shoryuken::Worker.new.perform(sqs_msg, body)
+    end
+  end
+end