chewy 6.0.0 → 7.5.1

data/spec/chewy/{type → index}/adapter/active_record_spec.rb

@@ -1,6 +1,12 @@
 require 'spec_helper'
 
-describe Chewy::Type::Adapter::ActiveRecord, :active_record do
+RawCity = Struct.new(:id) do
+  def rating
+    id * 10
+  end
+end
+
+describe Chewy::Index::Adapter::ActiveRecord, :active_record do
   before do
     stub_model(:city)
     stub_model(:country)
@@ -29,6 +35,68 @@ describe Chewy::Type::Adapter::ActiveRecord, :active_record do
     specify { expect(described_class.new(City.where(rating: 10)).default_scope).to eq(City.where(rating: 10)) }
   end
 
+  describe '.new' do
+    context 'with logger' do
+      let(:test_logger) { Logger.new('/dev/null') }
+      let(:default_scope_behavior) { :warn }
+
+      around do |example|
+        previous_logger = Chewy.logger
+        Chewy.logger = test_logger
+
+        previous_default_scope_behavior = Chewy.config.import_scope_cleanup_behavior
+        Chewy.config.import_scope_cleanup_behavior = default_scope_behavior
+
+        example.run
+      ensure
+        Chewy.logger = previous_logger
+        Chewy.config.import_scope_cleanup_behavior = previous_default_scope_behavior
+      end
+
+      specify do
+        expect(test_logger).to receive(:warn)
+        described_class.new(City.order(:id))
+      end
+
+      specify do
+        expect(test_logger).to receive(:warn)
+        described_class.new(City.offset(10))
+      end
+
+      specify do
+        expect(test_logger).to receive(:warn)
+        described_class.new(City.limit(10))
+      end
+
+      context 'ignore import scope warning' do
+        let(:default_scope_behavior) { :ignore }
+
+        specify do
+          expect(test_logger).not_to receive(:warn)
+          described_class.new(City.order(:id))
+        end
+
+        specify do
+          expect(test_logger).not_to receive(:warn)
+          described_class.new(City.offset(10))
+        end
+
+        specify do
+          expect(test_logger).not_to receive(:warn)
+          described_class.new(City.limit(10))
+        end
+      end
+
+      context 'raise exception on import scope with order/limit/offset' do
+        let(:default_scope_behavior) { :raise }
+
+        specify { expect { described_class.new(City.order(:id)) }.to raise_error(Chewy::ImportScopeCleanupError) }
+        specify { expect { described_class.new(City.limit(10)) }.to raise_error(Chewy::ImportScopeCleanupError) }
+        specify { expect { described_class.new(City.offset(10)) }.to raise_error(Chewy::ImportScopeCleanupError) }
+      end
+    end
+  end
+
   describe '#type_name' do
     specify { expect(described_class.new(City).type_name).to eq('city') }
     specify { expect(described_class.new(City.order(:id)).type_name).to eq('city') }
@@ -381,11 +449,21 @@ describe Chewy::Type::Adapter::ActiveRecord, :active_record do
       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: 1, &data_comparer.curry[cities[0].id])).to eq(false) }
-        specify { expect(subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[cities[1].id])).to eq(false) }
-        specify { expect(subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[cities[2].id])).to eq(false) }
-        specify { expect(subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[deleted[0].id])).to eq(false) }
-        specify { expect(subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[deleted[1].id])).to eq(false) }
+        specify do
+          expect(subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[cities[0].id])).to eq(false)
+        end
+        specify do
+          expect(subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[cities[1].id])).to eq(false)
+        end
+        specify do
+          expect(subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[cities[2].id])).to eq(false)
+        end
+        specify do
+          expect(subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[deleted[0].id])).to eq(false)
+        end
+        specify do
+          expect(subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[deleted[1].id])).to eq(false)
+        end
       end
 
       context 'ids' do
@@ -427,7 +505,10 @@ describe Chewy::Type::Adapter::ActiveRecord, :active_record 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])]) }
+        specify do
+          expect(subject.import_fields(Country.where('rating < 2'), fields: [:rating]))
+            .to match([contain_exactly([1, 0], [2, 1])])
+        end
       end
     end
 
@@ -436,21 +517,36 @@ describe Chewy::Type::Adapter::ActiveRecord, :active_record do
       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])]) }
+      specify do
+        expect(subject.import_fields(countries.first(2), fields: [:rating]))
+          .to match([contain_exactly([1, 0], [2, 1])])
+      end
     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 do
+        expect(subject.import_fields(batch_size: 2, fields: [:rating]))
+          .to match([contain_exactly([1, 0], [2, 1]), [[3, 2]]])
+      end
 
-      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 do
+        expect(subject.import_fields(Country.where('rating < 2'), batch_size: 2))
+          .to match([contain_exactly(1, 2)])
+      end
+      specify do
+        expect(subject.import_fields(Country.where('rating < 2'), batch_size: 2, fields: [:rating]))
+          .to match([contain_exactly([1, 0], [2, 1])])
+      end
 
       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]]]) }
+      specify do
+        expect(subject.import_fields(countries.first(2), batch_size: 1, fields: [:rating]))
+          .to match([[[1, 0]], [[2, 1]]])
+      end
     end
 
     context 'typecast' do
@@ -481,31 +577,29 @@ describe Chewy::Type::Adapter::ActiveRecord, :active_record do
       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 { expect(subject.load(city_ids, _index: 'users')).to eq(cities) }
+      specify { expect(subject.load(city_ids.reverse, _index: 'users')).to eq(cities.reverse) }
+      specify { expect(subject.load(deleted_ids, _index: 'users')).to eq([nil, nil]) }
+      specify { expect(subject.load(city_ids + deleted_ids, _index: 'users')).to eq([*cities, nil, nil]) }
       specify do
-        expect(subject.load(city_ids, _type: type, scope: -> { where(rating: 0) }))
+        expect(subject.load(city_ids, _index: 'users', 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))
+        expect(
+          subject.load(city_ids, _index: 'users', scope: -> { where(rating: 0) }, users: {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)))
+        expect(subject.load(city_ids, _index: 'users', 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])
+        expect(
+          subject.load(city_ids, _index: 'users', scope: City.where(rating: 1), users: {scope: -> { where(rating: 0) }})
+        ).to eq(cities.first(2) + [nil])
       end
     end
 
@@ -516,31 +610,53 @@ describe Chewy::Type::Adapter::ActiveRecord, :active_record do
       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(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 { expect(subject.load(city_ids, _index: 'users')).to eq(cities) }
+      specify { expect(subject.load(city_ids.reverse, _index: 'users')).to eq(cities.reverse) }
+      specify { expect(subject.load(deleted_ids, _index: 'users')).to eq([nil, nil]) }
+      specify { expect(subject.load(city_ids + deleted_ids, _index: 'users')).to eq([*cities, nil, nil]) }
       specify do
-        expect(subject.load(city_ids, _type: type, scope: -> { where(country_id: 0) }))
+        expect(subject.load(city_ids, _index: 'users', scope: -> { where(country_id: 0) }))
           .to eq(cities.first(2) + [nil])
       end
       specify do
-        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))
+        expect(
+          subject.load(
+            city_ids, _index: 'users', scope: -> { where(country_id: 0) }, users: {scope: -> { where(country_id: 1) }}
+          )
+        ).to eq([nil, nil] + cities.last(1))
       end
       specify do
-        expect(subject.load(city_ids, _type: type, scope: City.where(country_id: 1)))
+        expect(subject.load(city_ids, _index: 'users', scope: City.where(country_id: 1)))
           .to eq([nil, nil] + cities.last(1))
       end
       specify do
-        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])
+        expect(
+          subject.load(
+            city_ids, _index: 'users', scope: City.where(country_id: 1), users: {scope: -> { where(country_id: 0) }}
+          )
+        ).to eq(cities.first(2) + [nil])
+      end
+    end
+
+    context 'with raw_import option' do
+      subject { described_class.new(City) }
+
+      let!(:cities) { Array.new(3) { |i| City.create!(rating: i / 2) } }
+      let(:city_ids) { cities.map(&:id) }
+
+      let(:raw_import) { ->(hash) { RawCity.new(hash['id']) } }
+      it 'uses the custom loader' do
+        raw_cities = subject.load(city_ids, _index: 'cities', raw_import: raw_import).map do |c|
+          {id: c.id, rating: c.rating}
+        end
+
+        expect(raw_cities).to eq([
+          {id: 1, rating: 10},
+          {id: 2, rating: 20},
+          {id: 3, rating: 30}
+        ])
       end
     end
   end

data/spec/chewy/{type → index}/adapter/object_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Chewy::Type::Adapter::Object do
+describe Chewy::Index::Adapter::Object do
   before { stub_class(:product) }
   subject { described_class.new(:product) }
 
@@ -104,7 +104,13 @@ describe Chewy::Type::Adapter::Object do
     end
 
     context 'error handling' do
-      let(:products) { Array.new(3) { |i| double.tap { |product| allow(product).to receive_messages(rating: i.next) } } }
+      let(:products) do
+        Array.new(3) do |i|
+          double.tap do |product|
+            allow(product).to receive_messages(rating: i.next)
+          end
+        end
+      end
       let(:deleted) { Array.new(2) { |i| double(destroyed?: true, rating: i + 4) } }
       subject { described_class.new('product') }
 
@@ -135,13 +141,18 @@ describe Chewy::Type::Adapter::Object do
     context do
       subject { described_class.new(-> { objects }) }
       specify { expect(subject.import_fields(batch_size: 2)).to match([[1, 2], [3]]) }
-      specify { expect(subject.import_fields(fields: [:name], batch_size: 2)).to match([[[1, 'Name0'], [2, 'Name1']], [[3, 'Name2']]]) }
+      specify do
+        expect(subject.import_fields(fields: [:name], batch_size: 2))
+          .to match([[[1, 'Name0'], [2, 'Name1']], [[3, 'Name2']]])
+      end
     end
 
     context do
       subject { described_class.new(-> { objects }) }
       specify { expect(subject.import_fields(objects.first(2))).to match([[1, 2]]) }
-      specify { expect(subject.import_fields(objects.first(2), fields: [:name])).to match([[[1, 'Name0'], [2, 'Name1']]]) }
+      specify do
+        expect(subject.import_fields(objects.first(2), fields: [:name])).to match([[[1, 'Name0'], [2, 'Name1']]])
+      end
     end
 
     context do
@@ -178,7 +189,9 @@ describe Chewy::Type::Adapter::Object do
       context do
         subject { described_class.new(Product) }
         specify { expect(subject.import_fields(objects.first(2))).to match([[1, 2]]) }
-        specify { expect(subject.import_fields(objects.first(2), fields: [:name])).to match([[[1, 'Name0'], [2, 'Name1']]]) }
+        specify do
+          expect(subject.import_fields(objects.first(2), fields: [:name])).to match([[[1, 'Name0'], [2, 'Name1']]])
+        end
       end
 
       context 'batch_size' do
@@ -196,7 +209,9 @@ describe Chewy::Type::Adapter::Object do
     specify { expect(subject.import_references).to match([objects]) }
     specify { expect(subject.import_references(batch_size: 2)).to match([objects.first(2), objects.last(1)]) }
     specify { expect(subject.import_references(objects.first(2))).to match([objects.first(2)]) }
-    specify { expect(subject.import_references(objects.first(2), batch_size: 1)).to match([objects.first(1), [objects[1]]]) }
+    specify do
+      expect(subject.import_references(objects.first(2), batch_size: 1)).to match([objects.first(1), [objects[1]]])
+    end
   end
 
   describe '#load' do

data/spec/chewy/index/aliases_spec.rb

@@ -10,13 +10,13 @@ describe Chewy::Index::Aliases do
 
     context do
       before { DummiesIndex.create! }
-      specify { expect(DummiesIndex.indexes).to eq([]) }
+      specify { expect(DummiesIndex.indexes).to eq(['dummies']) }
     end
 
     context do
       before { DummiesIndex.create! }
       before { Chewy.client.indices.put_alias index: 'dummies', name: 'dummies_2013' }
-      specify { expect(DummiesIndex.indexes).to eq([]) }
+      specify { expect(DummiesIndex.indexes).to eq(['dummies']) }
     end
 
     context do
@@ -43,7 +43,7 @@ describe Chewy::Index::Aliases do
 
     context do
       before { DummiesIndex.create! '2013' }
-      specify { expect(DummiesIndex.aliases).to eq([]) }
+      specify { expect(DummiesIndex.aliases).to eq(['dummies']) }
     end
   end
 end