chewy 0.8.4 → 0.9.0

data/spec/chewy/type/import_spec.rb

@@ -15,7 +15,7 @@ describe Chewy::Type::Import do
     end
   end
 
-  let!(:dummy_cities) { 3.times.map { |i| City.create(id: i + 1, name: "name#{i}") } }
+  let!(:dummy_cities) { Array.new(3) { |i| City.create(id: i + 1, name: "name#{i}") } }
   let(:city) { CitiesIndex::City }
 
   describe '.import', :orm do
@@ -59,44 +59,57 @@ describe Chewy::Type::Import do
       dummy_cities.first.destroy
 
       imported = []
-      allow(CitiesIndex.client).to receive(:bulk) { |params| imported << params[:body]; nil }
+      allow(CitiesIndex.client).to receive(:bulk) { |params|
+        imported << params[:body]
+        nil
+      }
 
       city.import dummy_cities.map(&:id), batch_size: 2
       expect(imported.flatten).to match_array([
-        {index: {_id: 2, data: {'name' => 'name1'}}},
-        {index: {_id: 3, data: {'name' => 'name2'}}},
-        {delete: {_id: dummy_cities.first.id}}
+        { index: { _id: 2, data: { 'name' => 'name1' } } },
+        { index: { _id: 3, data: { 'name' => 'name2' } } },
+        { delete: { _id: dummy_cities.first.id } }
       ])
     end
 
     context ':bulk_size' do
+      specify { expect(city.import(dummy_cities.first, bulk_size: 1.2.kilobyte)).to eq(true) }
+      specify { expect(city.import(dummy_cities, bulk_size: 1.2.kilobyte)).to eq(true) }
+      specify { expect { city.import(dummy_cities, bulk_size: 1.2.kilobyte) }.to update_index(city).and_reindex(dummy_cities) }
+
       specify do
         dummy_cities.first.destroy
 
         imported = []
-        allow(CitiesIndex.client).to receive(:bulk) { |params| imported << params[:body]; nil }
+        allow(CitiesIndex.client).to receive(:bulk) { |params|
+          imported << params[:body]
+          nil
+        }
 
         city.import dummy_cities.map(&:id), bulk_size: 1.2.kilobyte
         expect(imported.flatten).to match_array([
-          %Q({"delete":{"_id":1}}),
-          %Q({"index":{"_id":2}}\n{"name":"name1"}\n{"index":{"_id":3}}\n{"name":"name2"})
+          %({"delete":{"_id":1}}\n),
+          %({"index":{"_id":2}}\n{"name":"name1"}\n{"index":{"_id":3}}\n{"name":"name2"}\n)
         ])
       end
 
       context do
-        let!(:dummy_cities) { 3.times.map { |i| City.create(id: i + 1, name: "name#{i}" * 20) } }
+        let!(:dummy_cities) { Array.new(3) { |i| City.create(id: i + 1, name: "name#{i}" * 20) } }
 
         specify do
           dummy_cities.first.destroy
 
           imported = []
-          allow(CitiesIndex.client).to receive(:bulk) { |params| imported << params[:body]; nil }
+          allow(CitiesIndex.client).to receive(:bulk) { |params|
+            imported << params[:body]
+            nil
+          }
 
           city.import dummy_cities.map(&:id), bulk_size: 1.2.kilobyte
           expect(imported.flatten).to match_array([
-            %Q({"delete":{"_id":1}}),
-            %Q({"index":{"_id":2}}\n{"name":"#{'name1' * 20}"}),
-            %Q({"index":{"_id":3}}\n{"name":"#{'name2' * 20}"})
+            %({"delete":{"_id":1}}\n),
+            %({"index":{"_id":2}}\n{"name":"#{'name1' * 20}"}\n),
+            %({"index":{"_id":3}}\n{"name":"#{'name2' * 20}"}\n)
           ])
         end
 
@@ -152,34 +165,34 @@ describe Chewy::Type::Import do
     context 'instrumentation payload' do
       specify do
         outer_payload = nil
-        ActiveSupport::Notifications.subscribe('import_objects.chewy') do |name, start, finish, id, payload|
+        ActiveSupport::Notifications.subscribe('import_objects.chewy') do |_name, _start, _finish, _id, payload|
           outer_payload = payload
         end
 
         dummy_cities.first.destroy
         city.import dummy_cities
-        expect(outer_payload).to eq({type: CitiesIndex::City, import: {delete: 1, index: 2}})
+        expect(outer_payload).to eq(type: CitiesIndex::City, import: { delete: 1, index: 2 })
       end
 
       specify do
         outer_payload = nil
-        ActiveSupport::Notifications.subscribe('import_objects.chewy') do |name, start, finish, id, payload|
+        ActiveSupport::Notifications.subscribe('import_objects.chewy') do |_name, _start, _finish, _id, payload|
           outer_payload = payload
         end
 
         dummy_cities.first.destroy
         city.import dummy_cities, batch_size: 2
-        expect(outer_payload).to eq({type: CitiesIndex::City, import: {delete: 1, index: 2}})
+        expect(outer_payload).to eq(type: CitiesIndex::City, import: { delete: 1, index: 2 })
       end
 
       specify do
         outer_payload = nil
-        ActiveSupport::Notifications.subscribe('import_objects.chewy') do |name, start, finish, id, payload|
+        ActiveSupport::Notifications.subscribe('import_objects.chewy') do |_name, _start, _finish, _id, payload|
           outer_payload = payload
         end
 
         city.import dummy_cities, batch_size: 2
-        expect(outer_payload).to eq({type: CitiesIndex::City, import: {index: 3}})
+        expect(outer_payload).to eq(type: CitiesIndex::City, import: { index: 3 })
       end
 
       context do
@@ -191,43 +204,51 @@ describe Chewy::Type::Import do
           end
         end
 
+        let(:write_failure_exception) do
+          'WriteFailureException; nested: MapperParsingException[object mapping for [city] ' \
+            'tried to parse field [name] as object, but got EOF, has a concrete value been provided to it?]; '
+        end
+        let(:mapper_parsing_exception) do
+          'MapperParsingException[object mapping for [city] tried to parse field [name] ' \
+            'as object, but got EOF, has a concrete value been provided to it?]'
+        end
+
         specify do
           skip_on_version_gte('2.0', 'format of exception changed in 2.x')
           outer_payload = nil
-          ActiveSupport::Notifications.subscribe('import_objects.chewy') do |name, start, finish, id, payload|
+          ActiveSupport::Notifications.subscribe('import_objects.chewy') do |_name, _start, _finish, _id, payload|
             outer_payload = payload
           end
 
           city.import dummy_cities, batch_size: 2
-          expect(outer_payload).to eq({
-            type: CitiesIndex::City,
+          expect(outer_payload).to eq(type: CitiesIndex::City,
             errors: {
               index: {
-                "WriteFailureException; nested: MapperParsingException[object mapping for [city] tried to parse field [name] as object, but got EOF, has a concrete value been provided to it?]; " => ["1"],
-                "MapperParsingException[object mapping for [city] tried to parse field [name] as object, but got EOF, has a concrete value been provided to it?]" => ["2", "3"]
+                write_failure_exception => ['1'],
+                mapper_parsing_exception => %w(2 3)
               }
             },
-            import: {index: 3}
-          })
+            import: { index: 3 })
         end
 
         specify do
           skip_on_version_lt('2.0', 'format of exception was changed')
           outer_payload = nil
-          ActiveSupport::Notifications.subscribe('import_objects.chewy') do |name, start, finish, id, payload|
+          ActiveSupport::Notifications.subscribe('import_objects.chewy') do |_name, _start, _finish, _id, payload|
             outer_payload = payload
           end
 
           city.import dummy_cities, batch_size: 2
-          expect(outer_payload).to eq({
-            type: CitiesIndex::City,
+          expect(outer_payload).to eq(type: CitiesIndex::City,
             errors: {
               index: {
-                {"type"=>"mapper_parsing_exception", "reason"=>"object mapping for [name] tried to parse field [name] as object, but found a concrete value"} => ["1", "2", "3"]
+                {
+                  'type' => 'mapper_parsing_exception',
+                  'reason' => 'object mapping for [name] tried to parse field [name] as object, but found a concrete value'
+                } => %w(1 2 3)
               }
             },
-            import: {index: 3}
-          })
+            import: { index: 3 })
         end
       end
     end
@@ -251,7 +272,7 @@ describe Chewy::Type::Import do
         before do
           stub_index(:cities) do
             define_type City do
-              field :name, type: 'object', value: ->{ name == 'name1' ? name : {name: name} }
+              field :name, type: 'object', value: -> { name == 'name1' ? name : { name: name } }
             end
           end
         end
@@ -291,12 +312,12 @@ describe Chewy::Type::Import do
       let(:child_city) { City.create(id: 4, country_id: country.id, name: 'city') }
       let(:city) { CountriesIndex::City }
 
-      specify { expect(city.import(child_city)).to eq(true)  }
+      specify { expect(city.import(child_city)).to eq(true) }
       specify { expect { city.import child_city }.to update_index(city).and_reindex(child_city) }
 
       specify do
         expect(CountriesIndex.client).to receive(:bulk).with(hash_including(
-          body: [{ index: { _id: child_city.id, parent: country.id, data: { 'name' => 'city' } } }]
+                                                               body: [{ index: { _id: child_city.id, parent: country.id, data: { 'name' => 'city' } } }]
         ))
 
         city.import child_city
@@ -309,10 +330,10 @@ describe Chewy::Type::Import do
           child_city.update_attributes(country_id: another_country.id)
 
           expect(CountriesIndex.client).to receive(:bulk).with(hash_including(
-            body: [
-              { delete: { _id: child_city.id, parent: country.id.to_s } },
-              { index: { _id: child_city.id, parent: another_country.id, data: { 'name' => 'city' } } }
-            ]
+                                                                 body: [
+                                                                   { delete: { _id: child_city.id, parent: country.id.to_s } },
+                                                                   { index: { _id: child_city.id, parent: another_country.id, data: { 'name' => 'city' } } }
+                                                                 ]
           ))
 
           city.import child_city
@@ -322,7 +343,7 @@ describe Chewy::Type::Import do
           child_city.destroy
 
           expect(CountriesIndex.client).to receive(:bulk).with(hash_including(
-            body: [{ delete: { _id: child_city.id, parent: country.id.to_s } }]
+                                                                 body: [{ delete: { _id: child_city.id, parent: country.id.to_s } }]
           ))
 
           city.import child_city
@@ -332,11 +353,18 @@ describe Chewy::Type::Import do
           child_city.destroy
 
           expect(CountriesIndex.client).to receive(:bulk).with(hash_including(
-            body: [{ delete: { _id: child_city.id, parent: country.id.to_s } }]
+                                                                 body: [{ delete: { _id: child_city.id, parent: country.id.to_s } }]
           ))
 
           city.import child_city.id
         end
+
+        specify do
+          child_city.destroy
+
+          expect(city.import(child_city)).to eq(true)
+          expect(city.import(child_city)).to eq(true)
+        end
       end
     end
 
@@ -359,12 +387,12 @@ describe Chewy::Type::Import do
         end
       end
 
-      specify { expect(country.import(canada)).to eq(true)  }
+      specify { expect(country.import(canada)).to eq(true) }
       specify { expect { country.import(canada) }.to update_index(country).and_reindex(canada.country_code) }
 
       specify do
         expect(CountriesIndex.client).to receive(:bulk).with(hash_including(
-          body: [{ index: { _id: canada.country_code, data: { 'name' => 'Canada', 'rating' => 4 } } }]
+                                                               body: [{ index: { _id: canada.country_code, data: { 'name' => 'Canada', 'rating' => 4 } } }]
         ))
 
         country.import canada
@@ -374,7 +402,7 @@ describe Chewy::Type::Import do
         canada.update_attributes(rating: 9)
 
         expect(CountriesIndex.client).to receive(:bulk).with(hash_including(
-          body: [{ index: { _id: canada.country_code, data: { 'name' => 'Canada', 'rating' => 9 } } }]
+                                                               body: [{ index: { _id: canada.country_code, data: { 'name' => 'Canada', 'rating' => 9 } } }]
         ))
 
         country.import canada
@@ -384,12 +412,11 @@ describe Chewy::Type::Import do
         canada.destroy
 
         expect(CountriesIndex.client).to receive(:bulk).with(hash_including(
-          body: [{ delete: { _id: canada.country_code } }]
+                                                               body: [{ delete: { _id: canada.country_code } }]
         ))
 
         country.import canada
       end
-
     end
 
     context 'default_import_options is set' do
@@ -426,7 +453,11 @@ describe Chewy::Type::Import do
 
       specify do
         expect(ActiveSupport::Notifications).to receive(:unsubscribe)
-        city.import!(dummy_cities) rescue nil
+        begin
+          city.import!(dummy_cities)
+        rescue
+          nil
+        end
       end
     end
   end

data/spec/chewy/type/mapping_spec.rb

@@ -34,8 +34,8 @@ describe Chewy::Type::Mapping do
   end
 
   describe '.agg' do
-    specify { expect(product._agg_defs[:named_agg].call).to eq({ avg: { field: 'title.subfield1' } }) }
-    specify { expect(review._agg_defs[:named_agg].call).to eq({ avg: { field: 'comments.rating' } }) }
+    specify { expect(product._agg_defs[:named_agg].call).to eq(avg: { field: 'title.subfield1' }) }
+    specify { expect(review._agg_defs[:named_agg].call).to eq(avg: { field: 'comments.rating' }) }
   end
 
   describe '.field' do
@@ -68,26 +68,26 @@ describe Chewy::Type::Mapping do
           end
         end
 
-        specify { expect(product.mappings_hash[:product][:_parent]).to eq({ type: 'project' }) }
+        specify { expect(product.mappings_hash[:product][:_parent]).to eq(type: 'project') }
       end
 
       context do
         before do
           stub_index(:products) do
             define_type :product do
-              root parent: {'type' => 'project'}, parent_id: -> { project_id } do
+              root parent: { 'type' => 'project' }, parent_id: -> { project_id } do
                 field :name, 'surname'
               end
             end
           end
         end
 
-        specify { expect(product.mappings_hash[:product][:_parent]).to eq({ type: 'project' }) }
+        specify { expect(product.mappings_hash[:product][:_parent]).to eq(type: 'project') }
       end
     end
   end
 
-  context "no root element call" do
+  context 'no root element call' do
     before do
       stub_index(:products) do
         define_type :product do

data/spec/chewy/type/observe_spec.rb

@@ -8,14 +8,20 @@ describe Chewy::Type::Observe do
       end
     end
 
-    let(:backreferenced) { 3.times.map { |i| double(id: i) } }
-
-    specify { expect { DummiesIndex::Dummy.update_index(backreferenced) }
-      .to raise_error Chewy::UndefinedUpdateStrategy }
-    specify { expect { DummiesIndex::Dummy.update_index([]) }
-      .not_to update_index('dummies#dummy') }
-    specify { expect { DummiesIndex::Dummy.update_index(nil) }
-      .not_to update_index('dummies#dummy') }
+    let(:backreferenced) { Array.new(3) { |i| double(id: i) } }
+
+    specify do
+      expect { DummiesIndex::Dummy.update_index(backreferenced) }
+        .to raise_error Chewy::UndefinedUpdateStrategy
+    end
+    specify do
+      expect { DummiesIndex::Dummy.update_index([]) }
+        .not_to update_index('dummies#dummy')
+    end
+    specify do
+      expect { DummiesIndex::Dummy.update_index(nil) }
+        .not_to update_index('dummies#dummy')
+    end
   end
 
   context 'integration', :orm do
@@ -23,10 +29,10 @@ describe Chewy::Type::Observe do
 
     before do
       city_countries_update_proc = if adapter == :sequel
-          ->(*) { previous_changes.try(:[], :country_id) || country }
-        else
-          ->(*) { changes['country_id'] || previous_changes['country_id'] || country }
-        end
+        ->(*) { previous_changes.try(:[], :country_id) || country }
+      else
+        ->(*) { changes['country_id'] || previous_changes['country_id'] || country }
+      end
 
       stub_model(:city) do
         update_index(->(city) { "cities##{city.class.name.underscore}" }) { self }
@@ -35,7 +41,7 @@ describe Chewy::Type::Observe do
 
       stub_model(:country) do
         update_index('cities#city', if: -> { update_condition }) { cities }
-        update_index(->{ "countries##{self.class.name.underscore}" }, :self)
+        update_index(-> { "countries##{self.class.name.underscore}" }, :self)
         attr_accessor :update_condition
       end
 
@@ -75,7 +81,7 @@ describe Chewy::Type::Observe do
     context do
       let!(:country) do
         Chewy.strategy(:atomic) do
-          cities = 2.times.map { |i| City.create!(id: i) }
+          cities = Array.new(2) { |i| City.create!(id: i) }
           if adapter == :sequel
             Country.create(id: 1, update_condition: update_condition).tap do |country|
               cities.each { |city| country.add_city(city) }

data/spec/chewy/type/witchcraft_spec.rb

@@ -15,7 +15,7 @@ describe Chewy::Type::Witchcraft do
 
   describe '#cauldron' do
     let(:type) { ProductsIndex::Product }
-    let(:object) { }
+    let(:object) {}
 
     context 'empty mapping' do
       mapping {}
@@ -28,7 +28,7 @@ describe Chewy::Type::Witchcraft do
         field :age
         field :tags
       end
-      let(:attributes) { { name: 'Name', age: 13, tags: %w[Ruby RoR] } }
+      let(:attributes) { { name: 'Name', age: 13, tags: %w(Ruby RoR) } }
 
       context do
         let(:object) { double(attributes) }
@@ -44,12 +44,12 @@ describe Chewy::Type::Witchcraft do
     context 'simple lambdas' do
       mapping do
         field :name
-        field :age, value: -> (obj) {
+        field :age, value: lambda { |obj|
           obj.age if obj
         }
         field :tags, value: -> { tags.map(&:to_sym) }
       end
-      let(:attributes) { { name: 'Name', age: 13, tags: %w[Ruby RoR] } }
+      let(:attributes) { { name: 'Name', age: 13, tags: %w(Ruby RoR) } }
 
       context do
         let(:object) { double(attributes) }
@@ -59,14 +59,14 @@ describe Chewy::Type::Witchcraft do
 
     context 'crutches' do
       mapping do
-        field :name, value: -> (o, c) { c.names[0] }
+        field :name, value: ->(_o, c) { c.names[0] }
       end
       let(:attributes) { { name: 'Name' } }
 
       context do
         let(:object) { double(attributes) }
         let(:crutches) { double(names: ['Other']) }
-        specify { expect(type.cauldron.brew(object, crutches)).to eq({name: 'Other'}.as_json) }
+        specify { expect(type.cauldron.brew(object, crutches)).to eq({ name: 'Other' }.as_json) }
       end
     end
 
@@ -79,14 +79,18 @@ describe Chewy::Type::Witchcraft do
           end
         end
 
-        let(:object) { double(queries: [
-          {title: 'Title1', body: 'Body1'},
-          {title: 'Title2', body: 'Body2'}
-        ]) }
-        specify { expect(type.cauldron.brew(object)).to eq({ queries: [
-          {title: 'Title1', body: 'This Body1'},
-          {title: 'Title2', body: 'This Body2'}
-        ] }.as_json) }
+        let(:object) do
+          double(queries: [
+            { title: 'Title1', body: 'Body1' },
+            { title: 'Title2', body: 'Body2' }
+          ])
+        end
+        specify do
+          expect(type.cauldron.brew(object)).to eq({ queries: [
+            { title: 'Title1', body: 'This Body1' },
+            { title: 'Title2', body: 'This Body2' }
+          ] }.as_json)
+        end
       end
 
       context do
@@ -97,14 +101,18 @@ describe Chewy::Type::Witchcraft do
           end
         end
 
-        let(:object) { double(queries: [
-          double(title: 'Title1', body: 'Body1'),
-          double(title: 'Title2', body: 'Body2')
-        ]) }
-        specify { expect(type.cauldron.brew(object)).to eq({ queries: [
-          {title: 'Title1', body: 'This Body1'},
-          {title: 'Title2', body: 'This Body2'}
-        ] }.as_json) }
+        let(:object) do
+          double(queries: [
+            double(title: 'Title1', body: 'Body1'),
+            double(title: 'Title2', body: 'Body2')
+          ])
+        end
+        specify do
+          expect(type.cauldron.brew(object)).to eq({ queries: [
+            { title: 'Title1', body: 'This Body1' },
+            { title: 'Title2', body: 'This Body2' }
+          ] }.as_json)
+        end
       end
 
       context do
@@ -115,39 +123,77 @@ describe Chewy::Type::Witchcraft do
           end
         end
 
-        let(:object) { double(queries: [
-          double(title: 'Title1', body: 'Body1'),
-          double(title: 'Title2', body: 'Body2')
-        ]) }
-        specify { expect(type.cauldron.brew(object)).to eq({ queries: [
-          {title: 'Title1', body: 'This Body1'},
-          {title: 'Title2', body: 'This Body2'}
-        ] }.as_json) }
+        let(:object) do
+          double(queries: [
+            double(title: 'Title1', body: 'Body1'),
+            double(title: 'Title2', body: 'Body2')
+          ])
+        end
+        specify do
+          expect(type.cauldron.brew(object)).to eq({ queries: [
+            { title: 'Title1', body: 'This Body1' },
+            { title: 'Title2', body: 'This Body2' }
+          ] }.as_json)
+        end
       end
 
       context do
         mapping do
           field :queries do
-            field :fields, value: -> (o, q) { q.fields } do
+            field :fields, value: ->(_o, q) { q.fields } do
               field :first
-              field :second, value: -> (o, q, f, c) {
+              field :second, value: lambda { |_o, q, f, c|
                 q.value + (f.respond_to?(:second) ? f.second : c.second)
               }
             end
           end
         end
 
-        let(:object) { double(queries: [
-          double(value: 'Value1', fields: [double(first: 'First1', second: 'Second1'), {first: 'First2'}]),
-          double(value: 'Value2', fields: double(first: 'First3', second: 'Second2', third: 'Third'))
-        ]) }
-        specify { expect(type.cauldron.brew(object, double(second: 'Crutch'))).to eq({queries: [
-          {fields: [
-            {first: 'First1', second: 'Value1Second1'},
-            {first: 'First2', second: 'Value1Crutch'}
-          ]},
-          {fields: {first: 'First3', second: 'Value2Second2'}}
-        ]}.as_json) }
+        let(:object) do
+          double(queries: [
+            double(value: 'Value1', fields: [double(first: 'First1', second: 'Second1'), { first: 'First2' }]),
+            double(value: 'Value2', fields: double(first: 'First3', second: 'Second2', third: 'Third'))
+          ])
+        end
+        specify do
+          expect(type.cauldron.brew(object, double(second: 'Crutch'))).to eq({ queries: [
+            { fields: [
+              { first: 'First1', second: 'Value1Second1' },
+              { first: 'First2', second: 'Value1Crutch' }
+            ] },
+            { fields: { first: 'First3', second: 'Value2Second2' } }
+          ] }.as_json)
+        end
+      end
+    end
+
+    context 'dynamic fields' do
+      mapping do
+        [[:name], [:age]].each do |param|
+          field param.first, value: ->(o) { o.send(param[0]) if param[0] }
+        end
+      end
+      let(:attributes) { { name: 'Name', age: 13 } }
+
+      context do
+        let(:object) { double(attributes) }
+        specify { expect(type.cauldron.brew(object)).to eq(attributes.as_json) }
+      end
+    end
+
+    context 'dynamic fields' do
+      mapping do
+        def self.custom_value(field)
+          ->(o) { o.send(field) }
+        end
+
+        field :name, value: custom_value(:name)
+      end
+      let(:attributes) { { name: 'Name' } }
+
+      context do
+        let(:object) { double(attributes) }
+        specify { expect(type.cauldron.brew(object)).to eq(attributes.as_json) }
       end
     end
   end