chewy 5.1.0 → 7.2.7

data/spec/chewy/search/pagination/will_paginate_examples.rb

@@ -1,63 +0,0 @@
-require 'spec_helper'
-
-shared_examples :will_paginate do |request_base_class|
-  before { Chewy.massacre }
-
-  before do
-    stub_index(:products) do
-      define_type(:product) do
-        field :name
-        field :age, type: 'integer'
-      end
-    end
-  end
-
-  let(:except_fields) { %w[_score _explanation] }
-  let(:request_class) do
-    Class.new(request_base_class).tap do |k|
-      k.include Chewy::Search::Pagination::WillPaginate
-    end
-  end
-  let(:search) { request_class.new(ProductsIndex).order(:age) }
-
-  specify { expect(search.total_pages).to eq(1) } # defaults to 1 on will_paginate
-
-  context do
-    let(:data) { Array.new(10) { |i| {id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next}.stringify_keys! } }
-
-    before { ProductsIndex::Product.import!(data.map { |h| double(h) }) }
-    before { allow(::WillPaginate).to receive_messages(per_page: 3) }
-
-    describe '#page' do
-      specify { expect(search.map { |e| e.attributes.except(*except_fields) }).to match_array(data) }
-      specify { expect(search.page(1).map { |e| e.attributes.except(*except_fields) }).to eq(data[0..2]) }
-      specify { expect(search.page(2).map { |e| e.attributes.except(*except_fields) }).to eq(data[3..5]) }
-    end
-
-    describe '#paginate' do
-      specify { expect(search.paginate(page: 2, per_page: 4).map { |e| e.attributes.except(*except_fields) }).to eq(data[4..7]) }
-      specify { expect(search.paginate(per_page: 2, page: 3).page(3).map { |e| e.attributes.except(*except_fields) }).to eq(data[4..5]) }
-      specify { expect(search.paginate(per_page: 5).map { |e| e.attributes.except(*except_fields) }).to eq(data[0..4]) }
-      specify { expect(search.paginate(per_page: 4).map { |e| e.attributes.except(*except_fields) }).to eq(data[0..3]) }
-    end
-
-    describe '#total_pages' do
-      specify { expect(search.paginate(page: 2, per_page: 5).total_pages).to eq(2) }
-      specify { expect(search.paginate(page: 3, per_page: 2).total_pages).to eq(5) }
-    end
-
-    describe '#total_entries' do
-      specify { expect(search.paginate(page: 1, per_page: 4).total_entries).to eq(10) }
-      specify { expect(search.query(range: {age: {gt: 20}}).limit(3).total_entries).to eq(8) }
-    end
-
-    describe '#load' do
-      specify { expect(search.paginate(per_page: 2, page: 1).load.first.age).to eq(10) }
-      specify { expect(search.paginate(per_page: 2, page: 3).load.first.age).to eq(50) }
-      specify { expect(search.paginate(per_page: 2, page: 3).load.page(2).load.first.age).to eq(30) }
-
-      specify { expect(search.paginate(per_page: 4, page: 1).load.total_count).to eq(10) }
-      specify { expect(search.paginate(per_page: 2, page: 3).load.total_pages).to eq(5) }
-    end
-  end
-end

data/spec/chewy/search/pagination/will_paginate_spec.rb

@@ -1,23 +0,0 @@
-require 'chewy/search/pagination/will_paginate_examples'
-
-describe Chewy::Search::Pagination::WillPaginate do
-  it_behaves_like :will_paginate, Chewy::Search::Request do
-    describe '#objects' do
-      let(:data) { Array.new(12) { |i| {id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next}.stringify_keys! } }
-
-      before { ProductsIndex::Product.import!(data.map { |h| double(h) }) }
-      before { allow(::WillPaginate).to receive_messages(per_page: 17) }
-
-      # specify { expect(search.current_page).to eq(1) }
-      # specify { expect(search.per_page).to eq(0) }
-      specify { expect(search.objects.class).to eq(WillPaginate::Collection) }
-      specify { expect(search.objects.total_entries).to eq(12) }
-      specify { expect(search.objects.per_page).to eq(17) }
-      specify { expect(search.objects.current_page).to eq(1) }
-      specify { expect(search.paginate(per_page: 2, page: 3).objects.class).to eq(WillPaginate::Collection) }
-      specify { expect(search.paginate(per_page: 2, page: 3).objects.total_entries).to eq(12) }
-      specify { expect(search.paginate(per_page: 2, page: 3).objects.per_page).to eq(2) }
-      specify { expect(search.paginate(per_page: 2, page: 3).objects.current_page).to eq(3) }
-    end
-  end
-end

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

@@ -1,5 +0,0 @@
-require 'chewy/search/parameters/string_array_storage_examples'
-
-describe Chewy::Search::Parameters::Types do
-  it_behaves_like :string_array_storage, nil
-end

data/spec/chewy/strategy/resque_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-if defined?(::Resque)
-  require 'resque_spec'
-
-  describe Chewy::Strategy::Resque, :orm do
-    around { |example| Chewy.strategy(:bypass) { example.run } }
-    before { ResqueSpec.reset! }
-    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') }
-
-    specify do
-      expect { [city, other_city].map(&:save!) }
-        .not_to update_index(CitiesIndex::City, strategy: :resque)
-    end
-
-    specify do
-      with_resque do
-        expect { [city, other_city].map(&:save!) }
-          .to update_index(CitiesIndex::City, strategy: :resque)
-          .and_reindex(city, other_city).only
-      end
-    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')
-    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

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

data/spec/chewy/type/actions_spec.rb

@@ -1,50 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Type::Actions, :orm do
-  before { Chewy.massacre }
-
-  before do
-    stub_model(:city)
-    stub_index(:cities) do
-      define_type City do
-        field :name
-        field :updated_at, type: 'date'
-      end
-    end
-  end
-
-  let!(:cities) { Array.new(3) { |i| City.create!(name: "Name#{i + 1}") } }
-  before { CitiesIndex::City.import }
-
-  describe '.reset' do
-    specify do
-      expect { CitiesIndex::City.reset }.to update_index(CitiesIndex::City)
-    end
-  end
-
-  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
-      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/mongoid_spec.rb

@@ -1,372 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Type::Adapter::Mongoid, :mongoid do
-  before do
-    stub_model(:city)
-    stub_model(:country)
-    if adapter == :mongoid && Mongoid::VERSION.start_with?('6')
-      City.belongs_to :country, optional: true
-    else
-      City.belongs_to :country
-    end
-    Country.has_many :cities
-  end
-
-  describe '#name' do
-    specify { expect(described_class.new(City).name).to eq('City') }
-    specify { expect(described_class.new(City.order(:id.asc)).name).to eq('City') }
-    specify { expect(described_class.new(City, name: 'town').name).to eq('Town') }
-
-    context do
-      before { stub_model('namespace/city') }
-
-      specify { expect(described_class.new(Namespace::City).name).to eq('City') }
-      specify { expect(described_class.new(Namespace::City.order(:id.asc)).name).to eq('City') }
-    end
-  end
-
-  describe '#default_scope' do
-    specify { expect(described_class.new(City).default_scope).to eq(City.all) }
-    specify { expect(described_class.new(City.order(:id.asc)).default_scope).to eq(City.all) }
-    specify { expect(described_class.new(City.limit(10)).default_scope).to eq(City.all) }
-    specify { expect(described_class.new(City.offset(10)).default_scope).to eq(City.all) }
-    specify { expect(described_class.new(City.where(rating: 10)).default_scope).to eq(City.where(rating: 10)) }
-  end
-
-  describe '#type_name' do
-    specify { expect(described_class.new(City).type_name).to eq('city') }
-    specify { expect(described_class.new(City.order(:id.asc)).type_name).to eq('city') }
-    specify { expect(described_class.new(City, name: 'town').type_name).to eq('town') }
-
-    context do
-      before { stub_model('namespace/city') }
-
-      specify { expect(described_class.new(Namespace::City).type_name).to eq('city') }
-      specify { expect(described_class.new(Namespace::City.order(:id.asc)).type_name).to eq('city') }
-    end
-  end
-
-  describe '#identify' do
-    subject { described_class.new(City) }
-    let!(:cities) { Array.new(3) { City.create! } }
-
-    specify { expect(subject.identify(City.all)).to match_array(cities.map(&:id).map(&:to_s)) }
-    specify { expect(subject.identify(cities)).to eq(cities.map(&:id).map(&:to_s)) }
-    specify { expect(subject.identify(cities.first)).to eq([cities.first.id.to_s]) }
-    specify { expect(subject.identify(cities.first(2).map(&:id))).to eq(cities.first(2).map(&:id).map(&:to_s)) }
-
-    context 'non-bson ids' do
-      let!(:cities) { Array.new(3) { |i| City.create! id: i + 1 } }
-
-      specify { expect(subject.identify(City.all)).to match_array(cities.map(&:id)) }
-      specify { expect(subject.identify(cities)).to eq(cities.map(&:id)) }
-      specify { expect(subject.identify(cities.first)).to eq([cities.first.id]) }
-      specify { expect(subject.identify(cities.first(2).map(&:id))).to eq(cities.first(2).map(&:id)) }
-    end
-  end
-
-  describe '#import' do
-    def import(*args)
-      result = []
-      subject.import(*args) { |data| result.push data }
-      result
-    end
-
-    context do
-      let!(:cities) { Array.new(3) { City.create! }.sort_by(&:id) }
-      let!(:deleted) { Array.new(4) { City.create!.tap(&:destroy) }.sort_by(&:id) }
-      subject { described_class.new(City) }
-
-      specify { expect(import).to match([{index: match_array(cities)}]) }
-      specify { expect(import(nil)).to eq([]) }
-
-      specify { expect(import(City.order(:id.asc))).to eq([{index: cities}]) }
-      specify do
-        expect(import(City.order(:id.asc), batch_size: 2))
-          .to eq([{index: cities.first(2)}, {index: cities.last(1)}])
-      end
-
-      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)}])
-      end
-      specify do
-        expect(import(cities, 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)}
-        ])
-      end
-
-      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)}])
-      end
-      specify do
-        expect(import(cities.map(&:id), 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)}
-        ])
-      end
-
-      specify { expect(import(cities.first, nil)).to eq([{index: [cities.first]}]) }
-      specify { expect(import(cities.first.id, nil)).to eq([{index: [cities.first]}]) }
-    end
-
-    context 'additional delete conditions' do
-      let!(:cities) { Array.new(4) { |i| City.create! rating: i } }
-      before { cities.last(2).map(&:destroy) }
-      subject { described_class.new(City) }
-
-      before do
-        City.class_eval do
-          def delete_already?
-            rating.in?([1, 3])
-          end
-        end
-      end
-      subject { described_class.new(City, delete_if: -> { delete_already? }) }
-
-      specify do
-        expect(import(City.all)).to eq([
-          {index: [cities[0]], delete: [cities[1]]}
-        ])
-      end
-      specify do
-        expect(import(cities)).to eq([
-          {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)}
-        ])
-      end
-    end
-
-    context 'default scope' do
-      let!(:cities) { Array.new(4) { |i| City.create!(id: i, rating: i / 3) }.sort_by(&:id) }
-      let!(:deleted) { Array.new(3) { |i| City.create!(id: 4 + i).tap(&:destroy) }.sort_by(&:id) }
-      subject { described_class.new(City.where(rating: 0)) }
-
-      specify { expect(import).to eq([{index: cities.first(3)}]) }
-
-      specify do
-        expect(import(City.where(:rating.lt => 2).order(:id.asc)))
-          .to eq([{index: cities.first(3)}])
-      end
-      specify do
-        expect(import(City.where(:rating.lt => 2).order(:id.asc), batch_size: 2))
-          .to eq([{index: cities.first(2)}, {index: [cities[2]]}])
-      end
-      specify do
-        expect(import(City.where(:rating.lt => 1).order(:id.asc)))
-          .to eq([{index: cities.first(3)}])
-      end
-      specify { expect(import(City.where(:rating.gt => 1).order(:id.asc))).to eq([]) }
-
-      specify do
-        expect(import(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)}])
-      end
-      specify do
-        expect(import(cities, batch_size: 2))
-          .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}])
-      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)}
-        ])
-      end
-
-      specify do
-        expect(import(cities.first(2).map(&:id)))
-          .to eq([{index: cities.first(2)}])
-      end
-      specify do
-        expect(import(cities.map(&: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]}])
-      end
-      specify do
-        expect(import(cities.map(&: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)}
-        ])
-      end
-    end
-
-    context 'error handling' do
-      let!(:cities) { Array.new(6) { City.create! } }
-      let!(:deleted) { Array.new(4) { City.create!.tap(&:destroy) } }
-      let(:ids) { (cities + deleted).map(&:id) }
-      subject { described_class.new(City) }
-
-      let(:data_comparer) do
-        lambda do |id, data|
-          objects = data[:index] || data[:delete]
-          !objects.map { |o| o.respond_to?(:id) ? o.id : o }.include?(id)
-        end
-      end
-
-      context 'implicit scope' do
-        specify { expect(subject.import { |_data| true }).to eq(true) }
-        specify { expect(subject.import { |_data| false }).to eq(false) }
-        specify { expect(subject.import(batch_size: 2, &data_comparer.curry[cities[0].id])).to eq(false) }
-        specify { expect(subject.import(batch_size: 2, &data_comparer.curry[cities[2].id])).to eq(false) }
-        specify { expect(subject.import(batch_size: 2, &data_comparer.curry[cities[4].id])).to eq(false) }
-        specify { expect(subject.import(batch_size: 2, &data_comparer.curry[deleted[0].id])).to eq(true) }
-        specify { expect(subject.import(batch_size: 2, &data_comparer.curry[deleted[2].id])).to eq(true) }
-      end
-
-      context 'explicit scope' do
-        let(:scope) { City.where(:id.in => ids) }
-
-        specify { expect(subject.import(scope) { |_data| true }).to eq(true) }
-        specify { expect(subject.import(scope) { |_data| false }).to eq(false) }
-        specify { expect(subject.import(scope, batch_size: 2, &data_comparer.curry[cities[0].id])).to eq(false) }
-        specify { expect(subject.import(scope, batch_size: 2, &data_comparer.curry[cities[2].id])).to eq(false) }
-        specify { expect(subject.import(scope, batch_size: 2, &data_comparer.curry[cities[4].id])).to eq(false) }
-        specify { expect(subject.import(scope, batch_size: 2, &data_comparer.curry[deleted[0].id])).to eq(true) }
-        specify { expect(subject.import(scope, batch_size: 2, &data_comparer.curry[deleted[2].id])).to eq(true) }
-      end
-
-      context 'objects' do
-        specify { expect(subject.import(cities + deleted) { |_data| true }).to eq(true) }
-        specify { expect(subject.import(cities + deleted) { |_data| false }).to eq(false) }
-        specify { expect(subject.import(cities + deleted, batch_size: 2, &data_comparer.curry[cities[0].id])).to eq(false) }
-        specify { expect(subject.import(cities + deleted, batch_size: 2, &data_comparer.curry[cities[2].id])).to eq(false) }
-        specify { expect(subject.import(cities + deleted, batch_size: 2, &data_comparer.curry[cities[4].id])).to eq(false) }
-        specify { expect(subject.import(cities + deleted, batch_size: 2, &data_comparer.curry[deleted[0].id])).to eq(false) }
-        specify { expect(subject.import(cities + deleted, batch_size: 2, &data_comparer.curry[deleted[2].id])).to eq(false) }
-      end
-
-      context 'ids' do
-        specify { expect(subject.import(ids) { |_data| true }).to eq(true) }
-        specify { expect(subject.import(ids) { |_data| false }).to eq(false) }
-        specify { expect(subject.import(ids, batch_size: 2, &data_comparer.curry[cities[0].id])).to eq(false) }
-        specify { expect(subject.import(ids, batch_size: 2, &data_comparer.curry[cities[2].id])).to eq(false) }
-        specify { expect(subject.import(ids, batch_size: 2, &data_comparer.curry[cities[4].id])).to eq(false) }
-        specify { expect(subject.import(ids, batch_size: 2, &data_comparer.curry[deleted[0].id])).to eq(false) }
-        specify { expect(subject.import(ids, batch_size: 2, &data_comparer.curry[deleted[2].id])).to eq(false) }
-      end
-    end
-  end
-
-  describe '#import_fields' do
-    subject { described_class.new(Country) }
-    let!(:countries) { Array.new(4) { |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, 4)]) }
-    specify { expect(subject.import_fields(fields: [:rating])).to match([contain_exactly([1, 0], [2, 1], [3, 2], [4, 3])]) }
-
-    context 'scopes' do
-      context do
-        subject { described_class.new(Country.includes(:cities)) }
-
-        specify { expect(subject.import_fields).to match([contain_exactly(1, 2, 3, 4)]) }
-        specify { expect(subject.import_fields(fields: [:rating])).to match([contain_exactly([1, 0], [2, 1], [3, 2], [4, 3])]) }
-      end
-
-      context 'ignores default scope if another scope is passed' do
-        subject { described_class.new(Country.where(:rating.gt => 2)) }
-
-        specify { expect(subject.import_fields(Country.where(:rating.lt => 2))).to match([contain_exactly(1, 2)]) }
-        specify { expect(subject.import_fields(Country.where(:rating.lt => 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), contain_exactly(3, 4)]) }
-      specify { expect(subject.import_fields(batch_size: 2, fields: [:rating])).to match([contain_exactly([1, 0], [2, 1]), contain_exactly([3, 2], [4, 3])]) }
-
-      specify { expect(subject.import_fields(Country.where(:rating.lt => 2), batch_size: 2)).to match([contain_exactly(1, 2)]) }
-      specify { expect(subject.import_fields(Country.where(:rating.lt => 2), batch_size: 2, fields: [:rating])).to match([contain_exactly([1, 0], [2, 1])]) }
-
-      specify { expect(subject.import_fields(1, 2, 3, batch_size: 2)).to match([contain_exactly(1, 2), [3]]) }
-      specify { expect(subject.import_fields(1, 2, 3, batch_size: 2, fields: [:rating])).to match([contain_exactly([1, 0], [2, 1]), [[3, 2]]]) }
-
-      specify { expect(subject.import_fields(countries.first(3), batch_size: 2)).to match([contain_exactly(1, 2), [3]]) }
-      specify { expect(subject.import_fields(countries.first(3), batch_size: 2, fields: [:rating])).to match([contain_exactly([1, 0], [2, 1]), [[3, 2]]]) }
-    end
-  end
-
-  describe '#load' do
-    context do
-      let!(:cities) { Array.new(3) { |i| City.create!(id: i, rating: i / 2) }.sort_by(&:id) }
-      let!(:deleted) { Array.new(2) { |i| City.create!(id: 3 + i).tap(&:destroy) }.sort_by(&:id) }
-      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(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(city_ids, _type: type, scope: -> { where(rating: 0) }))
-          .to eq(cities.first(2) + [nil])
-      end
-      specify do
-        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(city_ids, _type: type, scope: City.where(rating: 1)))
-          .to eq([nil, nil] + cities.last(1))
-      end
-      specify do
-        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
-  end
-end