chewy 5.0.0 → 5.2.0

data/lib/chewy/type/import.rb

@@ -10,7 +10,7 @@ module Chewy
 
       IMPORT_WORKER = lambda do |type, options, total, ids, index|
         ::Process.setproctitle("chewy [#{type}]: import data (#{index + 1}/#{total})")
-        routine = Routine.new(type, options)
+        routine = Routine.new(type, **options)
         type.adapter.import(*ids, routine.options) do |action_objects|
           routine.process(**action_objects)
         end
@@ -19,7 +19,7 @@ module Chewy
 
       LEFTOVERS_WORKER = lambda do |type, options, total, body, index|
         ::Process.setproctitle("chewy [#{type}]: import leftovers (#{index + 1}/#{total})")
-        routine = Routine.new(type, options)
+        routine = Routine.new(type, **options)
         routine.perform_bulk(body)
         routine.errors
       end
@@ -127,7 +127,7 @@ module Chewy
 
         def import_routine(*args)
           return if args.first.blank? && !args.first.nil?
-          routine = Routine.new(self, args.extract_options!)
+          routine = Routine.new(self, **args.extract_options!)
           routine.create_indexes!
 
           if routine.parallel_options

data/lib/chewy/type/mapping.rb

@@ -35,8 +35,8 @@ module Chewy
         #   end
         #
         def root(**options)
-          self.root_object ||= Chewy::Fields::Root.new(type_name, Chewy.default_root_options.merge(options))
-          root_object.update_options!(options)
+          self.root_object ||= Chewy::Fields::Root.new(type_name, **Chewy.default_root_options.merge(options))
+          root_object.update_options!(**options)
           yield if block_given?
           root_object
         end
@@ -126,9 +126,9 @@ module Chewy
         #
         def field(*args, **options, &block)
           if args.size > 1
-            args.map { |name| field(name, options) }
+            args.map { |name| field(name, **options) }
           else
-            expand_nested(Chewy::Fields::Base.new(args.first, options), &block)
+            expand_nested(Chewy::Fields::Base.new(args.first, **options), &block)
           end
         end
 

data/lib/chewy/type/observe.rb

@@ -63,10 +63,10 @@ module Chewy
           update_proc = Observe.update_proc(type_name, *args, &block)
 
           if Chewy.use_after_commit_callbacks
-            after_commit(callback_options, &update_proc)
+            after_commit(**callback_options, &update_proc)
           else
-            after_save(callback_options, &update_proc)
-            after_destroy(callback_options, &update_proc)
+            after_save(**callback_options, &update_proc)
+            after_destroy(**callback_options, &update_proc)
           end
         end
       end

data/lib/chewy/type/witchcraft.rb

@@ -58,7 +58,7 @@ module Chewy
       private
 
         def alicorn
-          @alicorn ||= class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          @alicorn ||= singleton_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
             -> (locals, object0, crutches) do
               #{composed_values(@type.root, 0)}
             end

data/lib/chewy/type/wrapper.rb

@@ -41,7 +41,7 @@ module Chewy
 
       %w[_id _type _index].each do |name|
         define_method name do
-          data[name]
+          _data[name]
         end
       end
 

data/lib/chewy/version.rb

@@ -1,3 +1,3 @@
 module Chewy
-  VERSION = '5.0.0'.freeze
+  VERSION = '5.2.0'.freeze
 end

data/lib/chewy.rb

@@ -132,7 +132,7 @@ module Chewy
     def create_type(index, target, options = {}, &block)
       type = Class.new(Chewy::Type)
 
-      adapter = adapters.find { |klass| klass.accepts?(target) }.new(target, options)
+      adapter = adapters.find { |klass| klass.accepts?(target) }.new(target, **options)
 
       index.const_set(adapter.name, type)
       type.send(:define_singleton_method, :index) { index }

data/spec/chewy/config_spec.rb

@@ -141,7 +141,7 @@ describe Chewy::Config do
     context 'when Rails::VERSION constant is defined' do
       it 'looks for configuration in "config/chewy.yml"' do
         module Rails
-          VERSION = '5.1.0'.freeze
+          VERSION = '5.1.1'.freeze
 
           def self.root
             Pathname.new(__dir__)

data/spec/chewy/fields/base_spec.rb

@@ -180,43 +180,45 @@ describe Chewy::Fields::Base do
         end
       end
 
+      # rubocop:disable Style/BracesAroundHashParameters
       specify do
-        expect(EventsIndex::Event.root.compose(
-                 id: 1, category: {id: 2, licenses: {id: 3, name: 'Name'}}
-        )).to eq('id' => 1, 'category' => {'id' => 2, 'licenses' => {'id' => 3, 'name' => 'Name'}})
+        expect(EventsIndex::Event.root.compose({
+          id: 1, category: {id: 2, licenses: {id: 3, name: 'Name'}}
+        })).to eq('id' => 1, 'category' => {'id' => 2, 'licenses' => {'id' => 3, 'name' => 'Name'}})
       end
 
       specify do
-        expect(EventsIndex::Event.root.compose(id: 1, category: [
+        expect(EventsIndex::Event.root.compose({id: 1, category: [
           {id: 2, 'licenses' => {id: 3, name: 'Name1'}},
           {id: 4, licenses: nil}
-        ])).to eq('id' => 1, 'category' => [
+        ]})).to eq('id' => 1, 'category' => [
           {'id' => 2, 'licenses' => {'id' => 3, 'name' => 'Name1'}},
           {'id' => 4, 'licenses' => nil.as_json}
         ])
       end
 
       specify do
-        expect(EventsIndex::Event.root.compose('id' => 1, category: {id: 2, licenses: [
+        expect(EventsIndex::Event.root.compose({'id' => 1, category: {id: 2, licenses: [
           {id: 3, name: 'Name1'}, {id: 4, name: 'Name2'}
-        ]})).to eq('id' => 1, 'category' => {'id' => 2, 'licenses' => [
+        ]}})).to eq('id' => 1, 'category' => {'id' => 2, 'licenses' => [
           {'id' => 3, 'name' => 'Name1'}, {'id' => 4, 'name' => 'Name2'}
         ]})
       end
 
       specify do
-        expect(EventsIndex::Event.root.compose(id: 1, category: [
+        expect(EventsIndex::Event.root.compose({id: 1, category: [
           {id: 2, licenses: [
             {id: 3, 'name' => 'Name1'}, {id: 4, name: 'Name2'}
           ]},
           {id: 5, licenses: []}
-        ])).to eq('id' => 1, 'category' => [
+        ]})).to eq('id' => 1, 'category' => [
           {'id' => 2, 'licenses' => [
             {'id' => 3, 'name' => 'Name1'}, {'id' => 4, 'name' => 'Name2'}
           ]},
           {'id' => 5, 'licenses' => []}
         ])
       end
+      # rubocop:enable Style/BracesAroundHashParameters
 
       specify do
         expect(EventsIndex::Event.root.compose(

data/spec/chewy/index/actions_spec.rb

@@ -55,7 +55,7 @@ describe Chewy::Index::Actions do
     context do
       before { DummiesIndex.create }
       specify do
-        expect { DummiesIndex.create! }.to raise_error(Elasticsearch::Transport::Transport::Errors::BadRequest).with_message(/index_already_exists_exception.*dummies/)
+        expect { DummiesIndex.create! }.to raise_error(Elasticsearch::Transport::Transport::Errors::BadRequest).with_message(/already exists.*dummies/)
       end
       specify { expect { DummiesIndex.create!('2013') }.to raise_error(Elasticsearch::Transport::Transport::Errors::BadRequest).with_message(/Invalid alias name \[dummies\]/) }
     end
@@ -67,7 +67,7 @@ describe Chewy::Index::Actions do
       specify { expect(DummiesIndex.aliases).to eq([]) }
       specify { expect(DummiesIndex.indexes).to eq(['dummies_2013']) }
       specify do
-        expect { DummiesIndex.create!('2013') }.to raise_error(Elasticsearch::Transport::Transport::Errors::BadRequest).with_message(/index_already_exists_exception.*dummies_2013/)
+        expect { DummiesIndex.create!('2013') }.to raise_error(Elasticsearch::Transport::Transport::Errors::BadRequest).with_message(/already exists.*dummies_2013/)
       end
       specify { expect(DummiesIndex.create!('2014')['acknowledged']).to eq(true) }
 

data/spec/chewy/journal_spec.rb

@@ -54,7 +54,7 @@ describe Chewy::Journal do
             expect(Chewy::Stash::Journal.exists?).to eq true
 
             Timecop.freeze(update_time)
-            cities.first.update_attributes!(name: 'Supername')
+            cities.first.update!(name: 'Supername')
 
             Timecop.freeze(destroy_time)
             countries.last.destroy

data/spec/chewy/search/parameters/indices_spec.rb

@@ -0,0 +1,191 @@
+require 'spec_helper'
+
+describe Chewy::Search::Parameters::Indices do
+  before do
+    stub_index(:first) do
+      define_type :one
+      define_type :two
+    end
+
+    stub_index(:second) do
+      define_type :three
+    end
+  end
+
+  subject { described_class.new(indices: FirstIndex, types: SecondIndex::Three) }
+
+  describe '#initialize' do
+    specify { expect(described_class.new.value).to eq(indices: [], types: []) }
+    specify { expect(described_class.new(nil).value).to eq(indices: [], types: []) }
+    specify { expect(described_class.new(foo: :whatever).value).to eq(indices: [], types: []) }
+    specify { expect(subject.value).to eq(indices: [FirstIndex], types: [SecondIndex::Three]) }
+  end
+
+  describe '#replace!' do
+    specify do
+      expect { subject.replace!(nil) }
+        .to change { subject.value }
+        .from(indices: [FirstIndex], types: [SecondIndex::Three])
+        .to(indices: [], types: [])
+    end
+
+    specify do
+      expect { subject.replace!(indices: SecondIndex, types: FirstIndex::One) }
+        .to change { subject.value }
+        .from(indices: [FirstIndex], types: [SecondIndex::Three])
+        .to(indices: [SecondIndex], types: [FirstIndex::One])
+    end
+  end
+
+  describe '#update!' do
+    specify do
+      expect { subject.update!(nil) }
+        .not_to change { subject.value }
+    end
+
+    specify do
+      expect { subject.update!(indices: SecondIndex, types: [FirstIndex::One, SecondIndex::Three]) }
+        .to change { subject.value }
+        .from(indices: [FirstIndex], types: [SecondIndex::Three])
+        .to(indices: [FirstIndex, SecondIndex], types: [SecondIndex::Three, FirstIndex::One])
+    end
+  end
+
+  describe '#merge!' do
+    specify do
+      expect { subject.merge!(described_class.new) }
+        .not_to change { subject.value }
+    end
+
+    specify do
+      expect { subject.merge!(described_class.new(indices: SecondIndex, types: [FirstIndex::One, SecondIndex::Three])) }
+        .to change { subject.value }
+        .from(indices: [FirstIndex], types: [SecondIndex::Three])
+        .to(indices: [FirstIndex, SecondIndex], types: [SecondIndex::Three, FirstIndex::One])
+    end
+  end
+
+  describe '#render' do
+    specify { expect(described_class.new.render).to eq({}) }
+    specify do
+      expect(described_class.new(
+        indices: FirstIndex
+      ).render).to eq(index: %w[first], type: %w[one two])
+    end
+    specify do
+      expect(described_class.new(
+        indices: :whatever
+      ).render).to eq(index: %w[whatever])
+    end
+    specify do
+      expect(described_class.new(
+        types: FirstIndex::One
+      ).render).to eq(index: %w[first], type: %w[one])
+    end
+    specify do
+      expect(described_class.new(
+        types: :whatever
+      ).render).to eq({})
+    end
+    specify do
+      expect(described_class.new(
+        indices: FirstIndex, types: SecondIndex::Three
+      ).render).to eq(index: %w[first second], type: %w[one three two])
+    end
+    specify do
+      expect(described_class.new(
+        indices: FirstIndex, types: :one
+      ).render).to eq(index: %w[first], type: %w[one])
+    end
+    specify do
+      expect(described_class.new(
+        indices: FirstIndex, types: :whatever
+      ).render).to eq(index: %w[first], type: %w[one two])
+    end
+    specify do
+      expect(described_class.new(
+        indices: FirstIndex, types: %i[one whatever]
+      ).render).to eq(index: %w[first], type: %w[one])
+    end
+    specify do
+      expect(described_class.new(
+        indices: :whatever, types: SecondIndex::Three
+      ).render).to eq(index: %w[second whatever], type: %w[three])
+    end
+    specify do
+      expect(described_class.new(
+        indices: :whatever, types: [SecondIndex::Three, :whatever]
+      ).render).to eq(index: %w[second whatever], type: %w[three whatever])
+    end
+    specify do
+      expect(described_class.new(
+        indices: [FirstIndex, :whatever], types: FirstIndex::One
+      ).render).to eq(index: %w[first whatever], type: %w[one])
+    end
+    specify do
+      expect(described_class.new(
+        indices: FirstIndex, types: [FirstIndex::One, :whatever]
+      ).render).to eq(index: %w[first], type: %w[one])
+    end
+    specify do
+      expect(described_class.new(
+        indices: FirstIndex, types: [SecondIndex::Three, :whatever]
+      ).render).to eq(index: %w[first second], type: %w[one three two])
+    end
+    specify do
+      expect(described_class.new(
+        indices: [FirstIndex, :whatever], types: [FirstIndex::One, :whatever]
+      ).render).to eq(index: %w[first whatever], type: %w[one whatever])
+    end
+    specify do
+      expect(described_class.new(
+        indices: [FirstIndex, :whatever], types: [SecondIndex::Three, FirstIndex::One]
+      ).render).to eq(index: %w[first second whatever], type: %w[one three])
+    end
+  end
+
+  describe '#==' do
+    specify { expect(described_class.new).to eq(described_class.new) }
+    specify do
+      expect(described_class.new(indices: SecondIndex, types: [SecondIndex::Three, :whatever]))
+        .to eq(described_class.new(indices: SecondIndex, types: :whatever))
+    end
+    specify do
+      expect(described_class.new(indices: :first, types: %w[one two]))
+        .to eq(described_class.new(indices: FirstIndex))
+    end
+    specify do
+      expect(described_class.new(indices: FirstIndex, types: SecondIndex::Three))
+        .not_to eq(described_class.new(indices: FirstIndex))
+    end
+  end
+
+  describe '#indices' do
+    specify do
+      expect(described_class.new(
+        indices: [FirstIndex, :whatever],
+        types: [SecondIndex::Three, :whatever]
+      ).indices).to contain_exactly(FirstIndex, SecondIndex)
+    end
+  end
+
+  describe '#types' do
+    specify do
+      expect(described_class.new(
+        indices: [FirstIndex, :whatever],
+        types: [SecondIndex::Three, :whatever]
+      ).types).to contain_exactly(
+        FirstIndex::One, FirstIndex::Two, SecondIndex::Three
+      )
+    end
+
+    specify do
+      expect(described_class.new(
+        indices: [FirstIndex, :whatever],
+        types: [FirstIndex::One, SecondIndex::Three, :whatever]
+      ).types).to contain_exactly(
+        FirstIndex::One, SecondIndex::Three
+      )
+    end
+  end
+end

data/spec/chewy/search/parameters_spec.rb

@@ -72,18 +72,20 @@ describe Chewy::Search::Parameters do
   describe '#merge!' do
     let(:first) { described_class.new(offset: 10, order: 'foo') }
     let(:second) { described_class.new(limit: 20, offset: 20, order: 'bar') }
+    let(:first_clone) { first.clone }
+    let(:second_clone) { second.clone }
 
     specify do
       expect { first.merge!(second) }.to change { first.clone }
         .to(described_class.new(limit: 20, offset: 20, order: %w[foo bar]))
     end
-    specify { expect { first.merge!(second) }.not_to change { second.clone } }
+    specify { expect { first.merge!(second) }.not_to change { second_clone } }
 
     specify do
       expect { second.merge!(first) }.to change { second.clone }
         .to(described_class.new(limit: 20, offset: 10, order: %w[bar foo]))
     end
-    specify { expect { second.merge!(first) }.not_to change { first.clone } }
+    specify { expect { second.merge!(first) }.not_to change { first_clone } }
 
     context 'spawns new storages for the merge' do
       let(:names) { %i[limit offset order] }
@@ -100,7 +102,22 @@ describe Chewy::Search::Parameters do
     subject { described_class.new(offset: 10, order: 'foo') }
 
     specify { expect(subject.render).to eq(body: {from: 10, sort: ['foo']}) }
-    specify { expect(described_class.new.render).to eq({}) }
+    specify { expect(described_class.new.render).to eq(body: {}) }
+
+    context do
+      subject { described_class.new(request_cache: true) }
+      specify { expect(subject.render).to eq(body: {}, request_cache: true) }
+    end
+
+    context do
+      subject { described_class.new(search_type: 'query_then_fetch') }
+      specify { expect(subject.render).to eq(body: {}, search_type: 'query_then_fetch') }
+    end
+
+    context do
+      subject { described_class.new(allow_partial_search_results: true) }
+      specify { expect(subject.render).to eq(body: {}, allow_partial_search_results: true) }
+    end
 
     context do
       subject { described_class.new(query: {foo: 'bar'}, filter: {moo: 'baz'}) }

data/spec/chewy/search/request_spec.rb

@@ -57,11 +57,11 @@ describe Chewy::Search::Request do
   describe '#inspect' do
     specify do
       expect(described_class.new(ProductsIndex).inspect)
-        .to eq('<Chewy::Search::Request {:index=>["products"], :type=>["product", "city", "country"], :body=>{}}>')
+        .to eq('<Chewy::Search::Request {:index=>["products"], :type=>["city", "country", "product"], :body=>{}}>')
     end
     specify do
       expect(ProductsIndex.limit(10).inspect)
-        .to eq('<ProductsIndex::Query {:index=>["products"], :type=>["product", "city", "country"], :body=>{:size=>10}}>')
+        .to eq('<ProductsIndex::Query {:index=>["products"], :type=>["city", "country", "product"], :body=>{:size=>10}}>')
     end
   end
 
@@ -151,13 +151,20 @@ describe Chewy::Search::Request do
   end
 
   describe '#request_cache' do
-    specify { expect(subject.request_cache(true).render[:body]).to include(request_cache: true) }
-    specify { expect(subject.request_cache(true).request_cache(false).render[:body]).to include(request_cache: false) }
-    specify { expect(subject.request_cache(true).request_cache(nil).render[:body]).to be_blank }
+    specify { expect(subject.request_cache(true).render).to include(request_cache: true) }
+    specify { expect(subject.request_cache(true).request_cache(false).render).to include(request_cache: false) }
+    specify { expect(subject.request_cache(true).request_cache(nil).render[:request_cache]).to be_blank }
     specify { expect { subject.request_cache(true) }.not_to change { subject.render } }
   end
 
-  %i[search_type preference timeout].each do |name|
+  describe '#search_type' do
+    specify { expect(subject.search_type('foo').render).to include(search_type: 'foo') }
+    specify { expect(subject.search_type('foo').search_type('bar').render).to include(search_type: 'bar') }
+    specify { expect(subject.search_type('foo').search_type(nil).render[:search_type]).to be_blank }
+    specify { expect { subject.search_type('foo') }.not_to change { subject.render } }
+  end
+
+  %i[preference timeout].each do |name|
     describe "##{name}" do
       specify { expect(subject.send(name, :foo).render[:body]).to include(name => 'foo') }
       specify { expect(subject.send(name, :foo).send(name, :bar).render[:body]).to include(name => 'bar') }
@@ -218,8 +225,17 @@ describe Chewy::Search::Request do
     specify { expect { subject.docvalue_fields(:foo) }.not_to change { subject.render } }
   end
 
+  describe '#indices' do
+    specify { expect(described_class.new(:products).render[:index]).to eq(%w[products]) }
+    specify { expect(subject.indices(:cities).render[:index]).to eq(%w[cities products]) }
+    specify { expect(subject.indices(CitiesIndex, :whatever).render[:index]).to eq(%w[cities products whatever]) }
+    specify { expect(subject.indices([CitiesIndex, :products]).render[:index]).to eq(%w[cities products]) }
+    specify { expect { subject.indices(:cities) }.not_to change { subject.render } }
+  end
+
   describe '#types' do
     specify { expect(subject.types(:product).render[:type]).to contain_exactly('product') }
+    specify { expect(described_class.new(ProductsIndex::City).types(ProductsIndex::Country).render[:type]).to match_array(%w[city country]) }
     specify { expect(subject.types(%i[product city]).types(nil).render[:type]).to match_array(%w[product city]) }
     specify { expect(subject.types(:product).types(:product, :city, :something).render[:type]).to match_array(%w[product city]) }
     specify { expect(subject.types(nil).render[:body]).to be_blank }
@@ -415,7 +431,7 @@ describe Chewy::Search::Request do
         expect(outer_payload).to eq(
           index: ProductsIndex,
           indexes: [ProductsIndex],
-          request: {index: ['products'], type: %w[product city country], body: {query: {match: {name: 'name3'}}}},
+          request: {index: ['products'], type: %w[city country product], body: {query: {match: {name: 'name3'}}}},
           type: [ProductsIndex::Product, ProductsIndex::City, ProductsIndex::Country],
           types: [ProductsIndex::Product, ProductsIndex::City, ProductsIndex::Country]
         )
@@ -644,7 +660,7 @@ describe Chewy::Search::Request do
         expect(outer_payload).to eq(
           index: ProductsIndex,
           indexes: [ProductsIndex],
-          request: {index: ['products'], type: %w[product city country], body: {query: {match: {name: 'name3'}}}, refresh: true},
+          request: {index: ['products'], type: %w[city country product], body: {query: {match: {name: 'name3'}}}, refresh: true},
           type: [ProductsIndex::Product, ProductsIndex::City, ProductsIndex::Country],
           types: [ProductsIndex::Product, ProductsIndex::City, ProductsIndex::Country]
         )
@@ -659,7 +675,7 @@ describe Chewy::Search::Request do
         expect(outer_payload).to eq(
           index: ProductsIndex,
           indexes: [ProductsIndex],
-          request: {index: ['products'], type: %w[product city country], body: {query: {match: {name: 'name3'}}}, refresh: false},
+          request: {index: ['products'], type: %w[city country product], body: {query: {match: {name: 'name3'}}}, refresh: false},
           type: [ProductsIndex::Product, ProductsIndex::City, ProductsIndex::Country],
           types: [ProductsIndex::Product, ProductsIndex::City, ProductsIndex::Country]
         )

data/spec/chewy/search/response_spec.rb

@@ -72,7 +72,10 @@ describe Chewy::Search::Response, :orm do
         Chewy::Search::Request.new(PlacesIndex)
           .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
 
@@ -84,7 +87,10 @@ describe Chewy::Search::Response, :orm 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) }
+      specify do
+        pending
+        expect(subject.timed_out?).to eq(true)
+      end
     end
   end
 

data/spec/chewy/search_spec.rb

@@ -71,12 +71,12 @@ describe Chewy::Search do
             filter { match name: "Name#{index}" }
           end
 
-          field :name, KEYWORD_FIELD
+          field :name, **KEYWORD_FIELD
           field :rating, type: :integer
         end
 
         define_type Country do
-          field :name, KEYWORD_FIELD
+          field :name, **KEYWORD_FIELD
           field :rating, type: :integer
         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
@@ -36,7 +41,15 @@ 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

data/spec/chewy/strategy/shoryuken_spec.rb

@@ -4,7 +4,12 @@ if defined?(::Shoryuken)
   require 'aws-sdk-sqs'
 
   describe Chewy::Strategy::Shoryuken do
-    around { |example| Chewy.strategy(:bypass) { example.run } }
+    around do |example|
+      shoryuken_settings = Chewy.settings[:shoryuken]
+      Chewy.settings[:shoryuken] = {queue: 'low'}
+      Chewy.strategy(:bypass) { example.run }
+      Chewy.settings[:shoryuken] = shoryuken_settings
+    end
     before { ::Shoryuken.groups.clear }
     before do
       stub_model(:city) do
@@ -31,7 +36,6 @@ if defined?(::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

data/spec/chewy/strategy/sidekiq_spec.rb

@@ -4,7 +4,12 @@ if defined?(::Sidekiq)
   require 'sidekiq/testing'
 
   describe Chewy::Strategy::Sidekiq do
-    around { |example| Chewy.strategy(:bypass) { example.run } }
+    around do |example|
+      sidekiq_settings = Chewy.settings[:sidekiq]
+      Chewy.settings[:sidekiq] = {queue: 'low'}
+      Chewy.strategy(:bypass) { example.run }
+      Chewy.settings[:sidekiq] = sidekiq_settings
+    end
     before { ::Sidekiq::Worker.clear_all }
     before do
       stub_model(:city) do
@@ -25,7 +30,6 @@ if defined?(::Sidekiq)
     end
 
     specify do
-      Chewy.settings[:sidekiq] = {queue: 'low'}
       expect(::Sidekiq::Client).to receive(:push).with(hash_including('queue' => 'low')).and_call_original
       ::Sidekiq::Testing.inline! do
         expect { [city, other_city].map(&:save!) }

data/spec/chewy/type/adapter/active_record_spec.rb

@@ -454,9 +454,9 @@ describe Chewy::Type::Adapter::ActiveRecord, :active_record do
       specify do
         expect(subject.import_fields(fields: [:updated_at], typecast: false))
           .to match([contain_exactly(
-            [1, match(/#{Time.now.strftime('%Y-%m-%d')}/)],
-            [2, match(/#{Time.now.strftime('%Y-%m-%d')}/)],
-            [3, match(/#{Time.now.strftime('%Y-%m-%d')}/)]
+            [1, match(/#{Time.now.utc.strftime('%Y-%m-%d')}/)],
+            [2, match(/#{Time.now.utc.strftime('%Y-%m-%d')}/)],
+            [3, match(/#{Time.now.utc.strftime('%Y-%m-%d')}/)]
           )])
       end
     end

data/spec/chewy/type/import/bulk_builder_spec.rb

@@ -117,7 +117,7 @@ describe Chewy::Type::Import::BulkBuilder do
       context 'updating parent' do
         before do
           PlacesIndex::City.import(city)
-          city.update_attributes(country_id: another_country.id)
+          city.update(country_id: another_country.id)
         end
         let(:index) { [city] }