chewy 0.9.0 → 0.10.0

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

@@ -1,7 +1,16 @@
 require 'spec_helper'
 
 describe Chewy::Type::Adapter::Mongoid, :mongoid do
-  before { stub_model(:city) }
+  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') }
@@ -68,54 +77,54 @@ describe Chewy::Type::Adapter::Mongoid, :mongoid do
       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).to match([{index: match_array(cities)}]) }
       specify { expect(import(nil)).to eq([]) }
 
-      specify { expect(import(City.order(:id.asc))).to eq([{ index: cities }]) }
+      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) }])
+          .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]}]) }
     end
 
     context 'additional delete conditions' do
@@ -134,19 +143,19 @@ describe Chewy::Type::Adapter::Mongoid, :mongoid do
 
       specify do
         expect(import(City.all)).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
@@ -156,67 +165,67 @@ describe Chewy::Type::Adapter::Mongoid, :mongoid do
       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 { 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) }])
+          .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]] }])
+          .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) }])
+          .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) }])
+          .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
@@ -278,35 +287,84 @@ describe Chewy::Type::Adapter::Mongoid, :mongoid do
     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(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

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

@@ -2,6 +2,7 @@ require 'spec_helper'
 
 describe Chewy::Type::Adapter::Object do
   before { stub_class(:product) }
+  subject { described_class.new(:product) }
 
   describe '#name' do
     specify { expect(described_class.new('product').name).to eq('Product') }
@@ -54,32 +55,32 @@ describe Chewy::Type::Adapter::Object do
       specify { expect(import).to eq([]) }
       specify { expect(import(nil)).to eq([]) }
 
-      specify { expect(import(objects)).to eq([{ index: objects }]) }
+      specify { expect(import(objects)).to eq([{index: objects}]) }
       specify do
         expect(import(objects, batch_size: 2))
-          .to eq([{ index: objects.first(2) }, { index: objects.last(1) }])
+          .to eq([{index: objects.first(2)}, {index: objects.last(1)}])
       end
-      specify { expect(import(objects, deleted)).to eq([{ index: objects, delete: deleted }]) }
+      specify { expect(import(objects, deleted)).to eq([{index: objects, delete: deleted}]) }
       specify do
         expect(import(objects, deleted, batch_size: 2)).to eq([
-          { index: objects.first(2) },
-          { index: objects.last(1), delete: deleted.first(1) },
-          { delete: deleted.last(1) }
+          {index: objects.first(2)},
+          {index: objects.last(1), delete: deleted.first(1)},
+          {delete: deleted.last(1)}
         ])
       end
 
-      specify { expect(import(objects.first, nil)).to eq([{ index: [objects.first] }]) }
+      specify { expect(import(objects.first, nil)).to eq([{index: [objects.first]}]) }
 
       context 'initial data' do
         subject { described_class.new -> { objects } }
 
-        specify { expect(import).to eq([{ index: objects }]) }
+        specify { expect(import).to eq([{index: objects}]) }
         specify { expect(import(nil)).to eq([]) }
 
-        specify { expect(import(objects[0..1])).to eq([{ index: objects[0..1] }]) }
+        specify { expect(import(objects[0..1])).to eq([{index: objects[0..1]}]) }
         specify do
           expect(import(batch_size: 2))
-            .to eq([{ index: objects.first(2) }, { index: objects.last(1) }])
+            .to eq([{index: objects.first(2)}, {index: objects.last(1)}])
         end
       end
 
@@ -96,7 +97,7 @@ describe Chewy::Type::Adapter::Object do
 
         specify do
           expect(import(deleted)).to eq([
-            { delete: deleted[0..2], index: deleted.last(1) }
+            {delete: deleted[0..2], index: deleted.last(1)}
           ])
         end
       end
@@ -121,35 +122,107 @@ describe Chewy::Type::Adapter::Object do
     end
   end
 
-  describe '#load' do
+  describe '#import_fields' do
+    let!(:objects) { Array.new(3) { |i| double(id: i + 1, name: "Name#{i}") } }
+    let!(:hashes) { Array.new(3) { |i| {id: i + 1, 'name' => "Name#{i}"} } }
+
     context do
-      subject { described_class.new('product') }
-      let(:objects) { Array.new(3) { double } }
+      subject { described_class.new(-> { objects }) }
+      specify { expect(subject.import_fields).to match([[1, 2, 3]]) }
+      specify { expect(subject.import_fields(fields: [:name])).to match([[[1, 'Name0'], [2, 'Name1'], [3, 'Name2']]]) }
+    end
 
-      specify { expect(subject.load(objects)).to eq(objects) }
+    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']]]) }
     end
 
-    [:wrap, :load_one].each do |load_method|
-      context do
-        before do
-          allow(Product).to receive(load_method) { |object|
-                              allow(object).to receive_messages(wrapped?: true)
-                              object
-                            }
+    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']]]) }
+    end
+
+    context do
+      subject { described_class.new(-> { hashes }) }
+      specify { expect(subject.import_fields).to match([[1, 2, 3]]) }
+      specify { expect(subject.import_fields(fields: [:name])).to match([[[1, 'Name0'], [2, 'Name1'], [3, 'Name2']]]) }
+    end
+
+    context do
+      subject { described_class.new(-> { [1, 2, 3] }) }
+      specify { expect(subject.import_fields).to match([[1, 2, 3]]) }
+      specify { expect(subject.import_fields(fields: [:name])).to match([[[1, nil], [2, nil], [3, nil]]]) }
+    end
+
+    context do
+      before do
+        stub_class(:product) do
+          def self.pluck(*fields)
+            if fields == [:id]
+              [1, 2, 3]
+            elsif fields.size > 1
+              [4, 5, 6]
+            end
+          end
         end
-        subject { described_class.new(Product) }
-        let(:objects) { Array.new(3) { double(wrapped?: false) } }
+      end
 
-        specify { expect(subject.load(objects)).to satisfy { |objects| objects.all?(&:wrapped?) } }
+      context do
+        subject { described_class.new(Product) }
+        specify { expect(subject.import_fields).to match([[1, 2, 3]]) }
+        specify { expect(subject.import_fields(fields: [:name])).to match([[4, 5, 6]]) }
       end
 
       context do
-        before { allow(Product).to receive(load_method) { |_object| nil } }
         subject { described_class.new(Product) }
-        let(:objects) { Array.new(3) { double(wrapped?: false) } }
+        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']]]) }
+      end
 
-        specify { expect(subject.load(objects)).to satisfy { |objects| objects.all?(&:nil?) } }
+      context 'batch_size' do
+        subject { described_class.new(Product) }
+        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([[4, 5], [6]]) }
       end
     end
   end
+
+  describe '#import_references' do
+    let!(:objects) { Array.new(3) { |i| double(id: i + 1, name: "Name#{i}") } }
+
+    subject { described_class.new(-> { objects }) }
+    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]]]) }
+  end
+
+  describe '#load' do
+    subject { described_class.new(Product) }
+    let(:objects) { (1..3).to_a }
+
+    specify { expect(subject.load(objects)).to be_nil }
+
+    context do
+      before { allow(Product).to receive(:load_all) { |objects| objects.map { |i| i * 3 } } }
+      specify { expect(subject.load(objects, value: 42)).to eq([3, 6, 9]) }
+    end
+
+    context do
+      before { allow(Product).to receive(:load_all) { |objects, options| objects.map { |i| i * options[:value] } } }
+      specify { expect(subject.load(objects, value: 2)).to eq([2, 4, 6]) }
+    end
+
+    context do
+      before { allow(Product).to receive(:load_one) { |object| object + 2 } }
+      specify { expect(subject.load(objects)).to eq((3..5).to_a) }
+    end
+
+    context do
+      before { allow(Product).to receive(:load_one) { |object, options| object + options[:value] } }
+      specify { expect(subject.load(objects, value: 42)).to eq((43..45).to_a) }
+    end
+  end
 end