chewy 0.9.0 → 5.2.0

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

@@ -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
@@ -50,5 +63,11 @@ if defined?(::ActiveJob)
       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/resque_spec.rb

@@ -36,5 +36,11 @@ if defined?(::Resque)
       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,70 @@
+require 'spec_helper'
+
+if defined?(::Shoryuken)
+  require 'aws-sdk-sqs'
+
+  describe Chewy::Strategy::Shoryuken do
+    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
+        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
+      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

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,6 +30,7 @@ if defined?(::Sidekiq)
     end
 
     specify do
+      expect(::Sidekiq::Client).to receive(:push).with(hash_including('queue' => 'low')).and_call_original
       ::Sidekiq::Testing.inline! do
         expect { [city, other_city].map(&:save!) }
           .to update_index(CitiesIndex::City, strategy: :sidekiq)
@@ -36,5 +42,11 @@ if defined?(::Sidekiq)
       expect(CitiesIndex::City).to receive(:import!).with([city.id, other_city.id], suffix: '201601')
       Chewy::Strategy::Sidekiq::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::Sidekiq::Worker.new.perform('CitiesIndex::City', [city.id, other_city.id], suffix: '201601')
+    end
   end
 end

data/spec/chewy/strategy_spec.rb

@@ -64,12 +64,12 @@ describe Chewy::Strategy do
       around { |example| Chewy.strategy(:bypass) { example.run } }
 
       specify do
-        expect(CitiesIndex::City).not_to receive(:import)
+        expect(CitiesIndex::City).not_to receive(:import!)
         [city, other_city].map(&:save!)
       end
 
       specify do
-        expect(CitiesIndex::City).to receive(:import).with([city.id, other_city.id]).once
+        expect(CitiesIndex::City).to receive(:import!).with([city.id, other_city.id]).once
         Chewy.strategy(:atomic) { [city, other_city].map(&:save!) }
       end
     end
@@ -78,12 +78,12 @@ describe Chewy::Strategy do
       around { |example| Chewy.strategy(:urgent) { example.run } }
 
       specify do
-        expect(CitiesIndex::City).to receive(:import).at_least(2).times
+        expect(CitiesIndex::City).to receive(:import!).at_least(2).times
         [city, other_city].map(&:save!)
       end
 
       specify do
-        expect(CitiesIndex::City).to receive(:import).with([city.id, other_city.id]).once
+        expect(CitiesIndex::City).to receive(:import!).with([city.id, other_city.id]).once
         Chewy.strategy(:atomic) { [city, other_city].map(&:save!) }
       end
 
@@ -94,7 +94,7 @@ describe Chewy::Strategy do
           end
 
           stub_model(:city) do
-            update_index('cities#city') { { name: name } }
+            update_index('cities#city') { {name: name} }
           end
         end
 
@@ -106,7 +106,7 @@ describe Chewy::Strategy do
         context do
           before do
             stub_model(:city) do
-              update_index('cities#city') { { id: id.to_s, name: name } }
+              update_index('cities#city') { {id: id.to_s, name: name} }
             end
           end
 

data/spec/chewy/type/actions_spec.rb

@@ -5,27 +5,46 @@ describe Chewy::Type::Actions, :orm do
 
   before do
     stub_model(:city)
-  end
-
-  before do
     stub_index(:cities) do
       define_type City do
         field :name
+        field :updated_at, type: 'date'
       end
     end
   end
 
-  let!(:dummy_cities) { Array.new(3) { |i| City.create(name: "name#{i}") } }
-  let(:city) { CitiesIndex::City }
+  let!(:cities) { Array.new(3) { |i| City.create!(name: "Name#{i + 1}") } }
+  before { CitiesIndex::City.import }
 
-  before do
-    city.import
+  describe '.reset' do
+    specify do
+      expect { CitiesIndex::City.reset }.to update_index(CitiesIndex::City)
+    end
   end
 
-  describe '.reset' do
+  describe '.sync' do
+    before do
+      cities.first.destroy
+      sleep(1) if ActiveSupport::VERSION::STRING < '4.1.0'
+      cities.last.update(name: 'Name5')
+    end
+    let!(:additional_city) { City.create!(name: 'Name4') }
+
     specify do
-      skip_on_plugin_missing_from_version('delete-by-query', '2.0')
-      expect { city.reset }.to update_index(city)
+      expect(CitiesIndex::City.sync).to match(
+        count: 3,
+        missing: contain_exactly(cities.first.id.to_s, additional_city.id.to_s),
+        outdated: [cities.last.id.to_s]
+      )
     end
+    specify do
+      expect { CitiesIndex::City.sync }.to update_index(CitiesIndex::City)
+        .and_reindex(additional_city, cities.last)
+        .and_delete(cities.first).only
+    end
+  end
+
+  describe '.journal' do
+    specify { expect(CitiesIndex::City.journal).to be_a(Chewy::Journal) }
   end
 end

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

@@ -1,7 +1,12 @@
 require 'spec_helper'
 
 describe Chewy::Type::Adapter::ActiveRecord, :active_record do
-  before { stub_model(:city) }
+  before do
+    stub_model(:city)
+    stub_model(:country)
+    City.belongs_to :country
+    Country.has_many :cities
+  end
 
   describe '#name' do
     specify { expect(described_class.new(City).name).to eq('City') }
@@ -72,73 +77,102 @@ describe Chewy::Type::Adapter::ActiveRecord, :active_record do
       let!(:deleted) { Array.new(4) { City.create!.tap(&:destroy) } }
       subject { described_class.new(City) }
 
-      specify { expect(import).to eq([{ index: cities }]) }
+      specify { expect(import).to eq([{index: cities}]) }
       specify { expect(import(nil)).to eq([]) }
 
-      specify { expect(import(City.order(:id))).to eq([{ index: cities }]) }
+      specify { expect(import(City.order(:id))).to eq([{index: cities}]) }
       specify do
         expect(import(City.order(:id), batch_size: 2))
-          .to eq([{ index: cities.first(2) }, { index: cities.last(1) }])
+          .to eq([{index: cities.first(2)}, {index: cities.last(1)}])
       end
 
-      specify { expect(import(cities)).to eq([{ index: cities }]) }
+      specify { expect(import(cities)).to eq([{index: cities}]) }
       specify do
         expect(import(cities, batch_size: 2))
-          .to eq([{ index: cities.first(2) }, { index: cities.last(1) }])
+          .to eq([{index: cities.first(2)}, {index: cities.last(1)}])
       end
       specify do
         expect(import(cities, deleted))
-          .to eq([{ index: cities }, { delete: deleted }])
+          .to eq([{index: cities}, {delete: deleted}])
       end
       specify do
         expect(import(cities, deleted, batch_size: 2)).to eq([
-          { index: cities.first(2) },
-          { index: cities.last(1) },
-          { delete: deleted.first(2) },
-          { delete: deleted.last(2) }
+          {index: cities.first(2)},
+          {index: cities.last(1)},
+          {delete: deleted.first(2)},
+          {delete: deleted.last(2)}
         ])
       end
 
-      specify { expect(import(cities.map(&:id))).to eq([{ index: cities }]) }
-      specify { expect(import(deleted.map(&:id))).to eq([{ delete: deleted.map(&:id) }]) }
+      specify { expect(import(cities.map(&:id))).to eq([{index: cities}]) }
+      specify { expect(import(deleted.map(&:id))).to eq([{delete: deleted.map(&:id)}]) }
       specify do
         expect(import(cities.map(&:id), batch_size: 2))
-          .to eq([{ index: cities.first(2) }, { index: cities.last(1) }])
+          .to eq([{index: cities.first(2)}, {index: cities.last(1)}])
       end
       specify do
         expect(import(cities.map(&:id), deleted.map(&:id)))
-          .to eq([{ index: cities }, { delete: deleted.map(&:id) }])
+          .to eq([{index: cities}, {delete: deleted.map(&:id)}])
       end
       specify do
         expect(import(cities.map(&:id), deleted.map(&:id), batch_size: 2)).to eq([
-          { index: cities.first(2) },
-          { index: cities.last(1) },
-          { delete: deleted.first(2).map(&:id) },
-          { delete: deleted.last(2).map(&:id) }
+          {index: cities.first(2)},
+          {index: cities.last(1)},
+          {delete: deleted.first(2).map(&:id)},
+          {delete: deleted.last(2).map(&:id)}
         ])
       end
 
-      specify { expect(import(cities.first, nil)).to eq([{ index: [cities.first] }]) }
-      specify { expect(import(cities.first.id, nil)).to eq([{ index: [cities.first] }]) }
+      specify { expect(import(cities.first, nil)).to eq([{index: [cities.first]}]) }
+      specify { expect(import(cities.first.id, nil)).to eq([{index: [cities.first]}]) }
 
       context 'raw_import' do
-        let(:probe) { double }
-        let(:converter) { ->(raw_hash) { probe.call(raw_hash) } }
-        let(:moscow) { OpenStruct.new(id: 1, name: 'Moscow') }
-        let(:warsaw) { OpenStruct.new(id: 2, name: 'Warsaw') }
-        let(:madrid) { OpenStruct.new(id: 3, name: 'Madrid') }
         before do
-          @one, @two, @three = City.all.to_a
+          stub_class(:dummy_city) do
+            def initialize(attributes = {})
+              @attributes = attributes
+            end
+
+            def method_missing(name, *args, &block)
+              if @attributes.key?(name.to_s)
+                @attributes[name.to_s]
+              else
+                super
+              end
+            end
+
+            def respond_to_missing?(name, _)
+              @attributes.key?(name.to_s)
+            end
+          end
         end
+        let!(:cities) { Array.new(3) { |i| City.create!(id: i + 1, name: "City#{i + 1}") } }
+        let(:converter) { ->(hash) { DummyCity.new(hash) } }
 
         it 'uses the raw import converter to make objects out of raw hashes from the database' do
           expect(City).not_to receive(:new)
 
-          expect(probe).to receive(:call).with(a_hash_including('id' => @one.id, 'name' => @one.name)).and_return(moscow)
-          expect(probe).to receive(:call).with(a_hash_including('id' => @two.id, 'name' => @one.name)).and_return(warsaw)
-          expect(probe).to receive(:call).with(a_hash_including('id' => @three.id, 'name' => @three.name)).and_return(madrid)
+          expect(import(City.where(nil), raw_import: converter)).to match([{index: match_array([
+            an_instance_of(DummyCity).and(have_attributes(id: 1, name: 'City1')),
+            an_instance_of(DummyCity).and(have_attributes(id: 2, name: 'City2')),
+            an_instance_of(DummyCity).and(have_attributes(id: 3, name: 'City3'))
+          ])}])
+        end
+
+        specify do
+          expect(import([1, 2, 3], raw_import: converter)).to match([{index: match_array([
+            an_instance_of(DummyCity).and(have_attributes(id: 1, name: 'City1')),
+            an_instance_of(DummyCity).and(have_attributes(id: 2, name: 'City2')),
+            an_instance_of(DummyCity).and(have_attributes(id: 3, name: 'City3'))
+          ])}])
+        end
 
-          expect(import(City.where(nil), raw_import: converter)).to eq([{ index: [moscow, warsaw, madrid] }])
+        specify do
+          expect(import(cities, raw_import: converter)).to match([{index: match_array([
+            an_instance_of(DummyCity).and(have_attributes(id: 1, name: 'City1')),
+            an_instance_of(DummyCity).and(have_attributes(id: 2, name: 'City2')),
+            an_instance_of(DummyCity).and(have_attributes(id: 3, name: 'City3'))
+          ])}])
         end
       end
     end
@@ -159,19 +193,19 @@ describe Chewy::Type::Adapter::ActiveRecord, :active_record do
 
       specify do
         expect(import(City.where(nil))).to eq([
-          { index: [cities[0]], delete: [cities[1]] }
+          {index: [cities[0]], delete: [cities[1]]}
         ])
       end
       specify do
         expect(import(cities)).to eq([
-          { index: [cities[0]], delete: [cities[1]] },
-          { delete: cities.last(2) }
+          {index: [cities[0]], delete: [cities[1]]},
+          {delete: cities.last(2)}
         ])
       end
       specify do
         expect(import(cities.map(&:id))).to eq([
-          { index: [cities[0]], delete: [cities[1]] },
-          { delete: cities.last(2).map(&:id) }
+          {index: [cities[0]], delete: [cities[1]]},
+          {delete: cities.last(2).map(&:id)}
         ])
       end
     end
@@ -182,47 +216,47 @@ describe Chewy::Type::Adapter::ActiveRecord, :active_record do
       let!(:deleted) { Array.new(3) { |i| City.create! { |c| c.rating = i + 10 }.tap(&:destroy) } }
       subject { described_class.new(City) }
 
-      specify { expect(import).to eq([{ index: cities }]) }
+      specify { expect(import).to eq([{index: cities}]) }
 
-      specify { expect(import(City.order(:rating))).to eq([{ index: cities }]) }
+      specify { expect(import(City.order(:rating))).to eq([{index: cities}]) }
       specify do
         expect(import(City.order(:rating), batch_size: 2))
-          .to eq([{ index: cities.first(2) }, { index: cities.last(1) }])
+          .to eq([{index: cities.first(2)}, {index: cities.last(1)}])
       end
 
-      specify { expect(import(cities)).to eq([{ index: cities }]) }
+      specify { expect(import(cities)).to eq([{index: cities}]) }
       specify do
         expect(import(cities, batch_size: 2))
-          .to eq([{ index: cities.first(2) }, { index: cities.last(1) }])
+          .to eq([{index: cities.first(2)}, {index: cities.last(1)}])
       end
       specify do
         expect(import(cities, deleted))
-          .to eq([{ index: cities }, { delete: deleted }])
+          .to eq([{index: cities}, {delete: deleted}])
       end
       specify do
         expect(import(cities, deleted, batch_size: 2)).to eq([
-          { index: cities.first(2) },
-          { index: cities.last(1) },
-          { delete: deleted.first(2) },
-          { delete: deleted.last(1) }
+          {index: cities.first(2)},
+          {index: cities.last(1)},
+          {delete: deleted.first(2)},
+          {delete: deleted.last(1)}
         ])
       end
 
-      specify { expect(import(cities.map(&:id))).to eq([{ index: cities }]) }
+      specify { expect(import(cities.map(&:id))).to eq([{index: cities}]) }
       specify do
         expect(import(cities.map(&:id), batch_size: 2))
-          .to eq([{ index: cities.first(2) }, { index: cities.last(1) }])
+          .to eq([{index: cities.first(2)}, {index: cities.last(1)}])
       end
       specify do
         expect(import(cities.map(&:id), deleted.map(&:id)))
-          .to eq([{ index: cities }, { delete: deleted.map(&:id) }])
+          .to eq([{index: cities}, {delete: deleted.map(&:id)}])
       end
       specify do
         expect(import(cities.map(&:id), deleted.map(&:id), batch_size: 2)).to eq([
-          { index: cities.first(2) },
-          { index: cities.last(1) },
-          { delete: deleted.first(2).map(&:id) },
-          { delete: deleted.last(1).map(&:id) }
+          {index: cities.first(2)},
+          {index: cities.last(1)},
+          {delete: deleted.first(2).map(&:id)},
+          {delete: deleted.last(1).map(&:id)}
         ])
       end
     end
@@ -232,67 +266,67 @@ describe Chewy::Type::Adapter::ActiveRecord, :active_record do
       let!(:deleted) { Array.new(3) { City.create!.tap(&:destroy) } }
       subject { described_class.new(City.where(rating: 0)) }
 
-      specify { expect(import).to eq([{ index: cities.first(3) }]) }
+      specify { expect(import).to eq([{index: cities.first(3)}]) }
 
       specify do
         expect(import(City.where('rating < 2')))
-          .to eq([{ index: cities.first(3) }])
+          .to eq([{index: cities.first(3)}])
       end
       specify do
         expect(import(City.where('rating < 2'), batch_size: 2))
-          .to eq([{ index: cities.first(2) }, { index: [cities[2]] }])
+          .to eq([{index: cities.first(2)}, {index: [cities[2]]}])
       end
       specify do
         expect(import(City.where('rating < 1')))
-          .to eq([{ index: cities.first(3) }])
+          .to eq([{index: cities.first(3)}])
       end
       specify { expect(import(City.where('rating > 1'))).to eq([]) }
 
       specify do
         expect(import(cities.first(2)))
-          .to eq([{ index: cities.first(2) }])
+          .to eq([{index: cities.first(2)}])
       end
       specify do
         expect(import(cities))
-          .to eq([{ index: cities.first(3) }, { delete: cities.last(1) }])
+          .to eq([{index: cities.first(3)}, {delete: cities.last(1)}])
       end
       specify do
         expect(import(cities, batch_size: 2))
-          .to eq([{ index: cities.first(2) }, { index: [cities[2]] }, { delete: cities.last(1) }])
+          .to eq([{index: cities.first(2)}, {index: [cities[2]]}, {delete: cities.last(1)}])
       end
       specify do
         expect(import(cities, deleted))
-          .to eq([{ index: cities.first(3) }, { delete: cities.last(1) + deleted }])
+          .to eq([{index: cities.first(3)}, {delete: cities.last(1) + deleted}])
       end
       specify do
         expect(import(cities, deleted, batch_size: 3)).to eq([
-          { index: cities.first(3) },
-          { delete: cities.last(1) + deleted.first(2) },
-          { delete: deleted.last(1) }
+          {index: cities.first(3)},
+          {delete: cities.last(1) + deleted.first(2)},
+          {delete: deleted.last(1)}
         ])
       end
 
       specify do
         expect(import(cities.first(2).map(&:id)))
-          .to eq([{ index: cities.first(2) }])
+          .to eq([{index: cities.first(2)}])
       end
       specify do
         expect(import(cities.map(&:id)))
-          .to eq([{ index: cities.first(3) }, { delete: [cities.last.id] }])
+          .to eq([{index: cities.first(3)}, {delete: [cities.last.id]}])
       end
       specify do
         expect(import(cities.map(&:id), batch_size: 2))
-          .to eq([{ index: cities.first(2) }, { index: [cities[2]] }, { delete: [cities.last.id] }])
+          .to eq([{index: cities.first(2)}, {index: [cities[2]]}, {delete: [cities.last.id]}])
       end
       specify do
         expect(import(cities.map(&:id), deleted.map(&:id)))
-          .to eq([{ index: cities.first(3) }, { delete: [cities.last.id] + deleted.map(&:id) }])
+          .to eq([{index: cities.first(3)}, {delete: [cities.last.id] + deleted.map(&:id)}])
       end
       specify do
         expect(import(cities.map(&:id), deleted.map(&:id), batch_size: 3)).to eq([
-          { index: cities.first(3) },
-          { delete: [cities.last.id] + deleted.first(2).map(&:id) },
-          { delete: deleted.last(1).map(&:id) }
+          {index: cities.first(3)},
+          {delete: [cities.last.id] + deleted.first(2).map(&:id)},
+          {delete: deleted.last(1).map(&:id)}
         ])
       end
     end
@@ -354,35 +388,111 @@ describe Chewy::Type::Adapter::ActiveRecord, :active_record do
     end
   end
 
+  describe '#import_fields' do
+    subject { described_class.new(Country) }
+    let!(:countries) { Array.new(3) { |i| Country.create!(rating: i) { |c| c.id = i + 1 } } }
+    let!(:cities) { Array.new(6) { |i| City.create!(rating: i + 3, country_id: (i + 4) / 2) { |c| c.id = i + 3 } } }
+
+    specify { expect(subject.import_fields).to match([contain_exactly(1, 2, 3)]) }
+    specify { expect(subject.import_fields(fields: [:rating])).to match([contain_exactly([1, 0], [2, 1], [3, 2])]) }
+
+    context 'scopes' do
+      context do
+        subject { described_class.new(Country.includes(:cities)) }
+
+        specify { expect(subject.import_fields).to match([contain_exactly(1, 2, 3)]) }
+        specify { expect(subject.import_fields(fields: [:rating])).to match([contain_exactly([1, 0], [2, 1], [3, 2])]) }
+      end
+
+      context do
+        subject { described_class.new(Country.joins(:cities)) }
+
+        specify { expect(subject.import_fields).to match([contain_exactly(2, 3)]) }
+        specify { expect(subject.import_fields(fields: [:rating])).to match([contain_exactly([2, 1], [3, 2])]) }
+      end
+
+      context 'ignores default scope if another scope is passed' do
+        subject { described_class.new(Country.joins(:cities)) }
+
+        specify { expect(subject.import_fields(Country.where('rating < 2'))).to match([contain_exactly(1, 2)]) }
+        specify { expect(subject.import_fields(Country.where('rating < 2'), fields: [:rating])).to match([contain_exactly([1, 0], [2, 1])]) }
+      end
+    end
+
+    context 'objects/ids' do
+      specify { expect(subject.import_fields(1, 2)).to match([contain_exactly(1, 2)]) }
+      specify { expect(subject.import_fields(1, 2, fields: [:rating])).to match([contain_exactly([1, 0], [2, 1])]) }
+
+      specify { expect(subject.import_fields(countries.first(2))).to match([contain_exactly(1, 2)]) }
+      specify { expect(subject.import_fields(countries.first(2), fields: [:rating])).to match([contain_exactly([1, 0], [2, 1])]) }
+    end
+
+    context 'batch_size' do
+      specify { expect(subject.import_fields(batch_size: 2)).to match([contain_exactly(1, 2), [3]]) }
+      specify { expect(subject.import_fields(batch_size: 2, fields: [:rating])).to match([contain_exactly([1, 0], [2, 1]), [[3, 2]]]) }
+
+      specify { expect(subject.import_fields(Country.where('rating < 2'), batch_size: 2)).to match([contain_exactly(1, 2)]) }
+      specify { expect(subject.import_fields(Country.where('rating < 2'), batch_size: 2, fields: [:rating])).to match([contain_exactly([1, 0], [2, 1])]) }
+
+      specify { expect(subject.import_fields(1, 2, batch_size: 1)).to match([[1], [2]]) }
+      specify { expect(subject.import_fields(1, 2, batch_size: 1, fields: [:rating])).to match([[[1, 0]], [[2, 1]]]) }
+
+      specify { expect(subject.import_fields(countries.first(2), batch_size: 1)).to match([[1], [2]]) }
+      specify { expect(subject.import_fields(countries.first(2), batch_size: 1, fields: [:rating])).to match([[[1, 0]], [[2, 1]]]) }
+    end
+
+    context 'typecast' do
+      specify { expect(subject.import_fields(typecast: false)).to match([contain_exactly(1, 2, 3)]) }
+      specify do
+        expect(subject.import_fields(fields: [:updated_at]).to_a)
+          .to match([contain_exactly(
+            [1, an_instance_of(Time)],
+            [2, an_instance_of(Time)],
+            [3, an_instance_of(Time)]
+          )])
+      end
+      specify do
+        expect(subject.import_fields(fields: [:updated_at], typecast: false))
+          .to match([contain_exactly(
+            [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
+  end
+
   describe '#load' do
     context do
       let!(:cities) { Array.new(3) { |i| City.create!(rating: i / 2) } }
       let!(:deleted) { Array.new(2) { City.create!.tap(&:destroy) } }
+      let(:city_ids) { cities.map(&:id) }
+      let(:deleted_ids) { deleted.map(&:id) }
 
       let(:type) { double(type_name: 'user') }
 
       subject { described_class.new(City) }
 
-      specify { expect(subject.load(cities.map { |c| double(id: c.id) }, _type: type)).to eq(cities) }
-      specify { expect(subject.load(cities.map { |c| double(id: c.id) }.reverse, _type: type)).to eq(cities.reverse) }
-      specify { expect(subject.load(deleted.map { |c| double(id: c.id) }, _type: type)).to eq([nil, nil]) }
-      specify { expect(subject.load((cities + deleted).map { |c| double(id: c.id) }, _type: type)).to eq([*cities, nil, nil]) }
+      specify { expect(subject.load(city_ids, _type: type)).to eq(cities) }
+      specify { expect(subject.load(city_ids.reverse, _type: type)).to eq(cities.reverse) }
+      specify { expect(subject.load(deleted_ids, _type: type)).to eq([nil, nil]) }
+      specify { expect(subject.load(city_ids + deleted_ids, _type: type)).to eq([*cities, nil, nil]) }
       specify do
-        expect(subject.load(cities.map { |c| double(id: c.id) }, _type: type, scope: -> { where(rating: 0) }))
+        expect(subject.load(city_ids, _type: type, scope: -> { where(rating: 0) }))
           .to eq(cities.first(2) + [nil])
       end
       specify do
-        expect(subject.load(cities.map { |c| double(id: c.id) },
-          _type: type, scope: -> { where(rating: 0) }, user: { scope: -> { where(rating: 1) } }))
+        expect(subject.load(city_ids,
+          _type: type, scope: -> { where(rating: 0) }, user: {scope: -> { where(rating: 1) }}))
           .to eq([nil, nil] + cities.last(1))
       end
       specify do
-        expect(subject.load(cities.map { |c| double(id: c.id) }, _type: type, scope: City.where(rating: 1)))
+        expect(subject.load(city_ids, _type: type, scope: City.where(rating: 1)))
           .to eq([nil, nil] + cities.last(1))
       end
       specify do
-        expect(subject.load(cities.map { |c| double(id: c.id) },
-          _type: type, scope: City.where(rating: 1), user: { scope: -> { where(rating: 0) } }))
+        expect(subject.load(city_ids,
+          _type: type, scope: City.where(rating: 1), user: {scope: -> { where(rating: 0) }}))
           .to eq(cities.first(2) + [nil])
       end
     end
@@ -391,31 +501,33 @@ describe Chewy::Type::Adapter::ActiveRecord, :active_record do
       before { stub_model(:city) { self.primary_key = 'rating' } }
       let!(:cities) { Array.new(3) { |i| City.create!(country_id: i / 2) { |c| c.rating = i + 7 } } }
       let!(:deleted) { Array.new(2) { |i| City.create! { |c| c.rating = i + 10 }.tap(&:destroy) } }
+      let(:city_ids) { cities.map(&:rating) }
+      let(:deleted_ids) { deleted.map(&:rating) }
 
       let(:type) { double(type_name: 'user') }
 
       subject { described_class.new(City) }
 
-      specify { expect(subject.load(cities.map { |c| double(id: c.id) }, _type: type)).to eq(cities) }
-      specify { expect(subject.load(cities.map { |c| double(id: c.id) }.reverse, _type: type)).to eq(cities.reverse) }
-      specify { expect(subject.load(deleted.map { |c| double(id: c.id) }, _type: type)).to eq([nil, nil]) }
-      specify { expect(subject.load((cities + deleted).map { |c| double(id: c.id) }, _type: type)).to eq([*cities, nil, nil]) }
+      specify { expect(subject.load(city_ids, _type: type)).to eq(cities) }
+      specify { expect(subject.load(city_ids.reverse, _type: type)).to eq(cities.reverse) }
+      specify { expect(subject.load(deleted_ids, _type: type)).to eq([nil, nil]) }
+      specify { expect(subject.load(city_ids + deleted_ids, _type: type)).to eq([*cities, nil, nil]) }
       specify do
-        expect(subject.load(cities.map { |c| double(id: c.id) }, _type: type, scope: -> { where(country_id: 0) }))
+        expect(subject.load(city_ids, _type: type, scope: -> { where(country_id: 0) }))
           .to eq(cities.first(2) + [nil])
       end
       specify do
-        expect(subject.load(cities.map { |c| double(id: c.id) },
-          _type: type, scope: -> { where(country_id: 0) }, user: { scope: -> { where(country_id: 1) } }))
+        expect(subject.load(city_ids,
+          _type: type, scope: -> { where(country_id: 0) }, user: {scope: -> { where(country_id: 1) }}))
           .to eq([nil, nil] + cities.last(1))
       end
       specify do
-        expect(subject.load(cities.map { |c| double(id: c.id) }, _type: type, scope: City.where(country_id: 1)))
+        expect(subject.load(city_ids, _type: type, scope: City.where(country_id: 1)))
           .to eq([nil, nil] + cities.last(1))
       end
       specify do
-        expect(subject.load(cities.map { |c| double(id: c.id) },
-          _type: type, scope: City.where(country_id: 1), user: { scope: -> { where(country_id: 0) } }))
+        expect(subject.load(city_ids,
+          _type: type, scope: City.where(country_id: 1), user: {scope: -> { where(country_id: 0) }}))
           .to eq(cities.first(2) + [nil])
       end
     end