chewy 0.8.3 → 0.8.4

data/spec/chewy/strategy/resque_spec.rb

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

data/spec/chewy/strategy/sidekiq_spec.rb

@@ -28,8 +28,13 @@ if defined?(::Sidekiq)
       ::Sidekiq::Testing.inline! do
         expect { [city, other_city].map(&:save!) }
           .to update_index(CitiesIndex::City, strategy: :sidekiq)
-          .and_reindex(city, other_city)
+          .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::Sidekiq::Worker.new.perform("CitiesIndex::City", [city.id, other_city.id], suffix: '201601')
+    end
   end
 end

data/spec/chewy/strategy_spec.rb

@@ -14,7 +14,7 @@ describe Chewy::Strategy do
   end
 
   describe '#push' do
-    specify { expect { strategy.push(:unexistant) }.to raise_error(NameError).with_message(/uninitialized constant.*Unexistant/) }
+    specify { expect { strategy.push(:unexistant) }.to raise_error(RuntimeError).with_message("Can't find update strategy `unexistant`") }
 
     specify do
       expect { strategy.push(:atomic) }
@@ -34,6 +34,18 @@ describe Chewy::Strategy do
     end
   end
 
+  describe '#wrap' do
+    specify { expect { strategy.wrap(:unexistant) {} }.to raise_error(RuntimeError).with_message("Can't find update strategy `unexistant`") }
+
+    specify do
+      expect do
+        strategy.wrap(:urgent) do
+          expect(strategy.current).to be_a(Chewy::Strategy::Urgent)
+        end
+      end.not_to change { strategy.current }
+    end
+  end
+
   context 'nesting', :orm do
     before do
       stub_model(:city) do

data/spec/chewy/type/actions_spec.rb

@@ -23,6 +23,9 @@ describe Chewy::Type::Actions, :orm do
   end
 
   describe '.reset' do
-    specify { expect { city.reset }.to update_index(city) }
+    specify do
+      skip_on_plugin_missing_from_version('delete-by-query', '2.0')
+      expect { city.reset }.to update_index(city)
+    end
   end
 end

data/spec/chewy/type/import_spec.rb

@@ -69,6 +69,43 @@ describe Chewy::Type::Import do
       ])
     end
 
+    context ':bulk_size' do
+      specify do
+        dummy_cities.first.destroy
+
+        imported = []
+        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"})
+        ])
+      end
+
+      context do
+        let!(:dummy_cities) { 3.times.map { |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 }
+
+          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}"})
+          ])
+        end
+
+        specify do
+          expect { city.import dummy_cities.map(&:id), bulk_size: 1.1.kilobyte }.to raise_error ArgumentError
+        end
+      end
+    end
+
     specify do
       expect(CitiesIndex.client).to receive(:bulk).with(hash_including(refresh: true))
       city.import dummy_cities
@@ -83,7 +120,8 @@ describe Chewy::Type::Import do
       before do
         names = %w(name0 name1)
 
-        criteria = if defined?(::Mongoid)
+        criteria = case adapter
+        when :mongoid
           { :name.in => names }
         else
           { name: names }
@@ -154,6 +192,7 @@ describe Chewy::Type::Import do
         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|
             outer_payload = payload
@@ -171,6 +210,25 @@ describe Chewy::Type::Import do
             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|
+            outer_payload = payload
+          end
+
+          city.import dummy_cities, batch_size: 2
+          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"]
+              }
+            },
+            import: {index: 3}
+          })
+        end
       end
     end
 
@@ -332,7 +390,18 @@ describe Chewy::Type::Import do
         country.import canada
       end
 
-    end  # END root id
+    end
+
+    context 'default_import_options is set' do
+      before do
+        CitiesIndex::City.default_import_options(batch_size: 500, bulk_size: 1.megabyte)
+      end
+
+      specify do
+        expect(CitiesIndex::City.adapter).to receive(:import).with(batch_size: 500, bulk_size: 1.megabyte)
+        CitiesIndex::City.import
+      end
+    end
   end
 
   describe '.import!', :orm do

data/spec/chewy/type/observe_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Chewy::Type::Import do
+describe Chewy::Type::Observe do
   describe '.update_index' do
     before do
       stub_index(:dummies) do
@@ -62,14 +62,14 @@ describe Chewy::Type::Import do
       let!(:country2) { Chewy.strategy(:atomic) { Country.create!(id: 2, update_condition: update_condition) } }
       let!(:city) { Chewy.strategy(:atomic) { City.create!(id: 1, country: country1) } }
 
-      specify { expect { city.save! }.to update_index('cities#city').and_reindex(city) }
-      specify { expect { city.save! }.to update_index('countries#country').and_reindex(country1) }
+      specify { expect { city.save! }.to update_index('cities#city').and_reindex(city).only }
+      specify { expect { city.save! }.to update_index('countries#country').and_reindex(country1).only }
 
-      specify { expect { city.update_attributes!(country: nil) }.to update_index('cities#city').and_reindex(city) }
-      specify { expect { city.update_attributes!(country: nil) }.to update_index('countries#country').and_reindex(country1) }
+      specify { expect { city.update_attributes!(country: nil) }.to update_index('cities#city').and_reindex(city).only }
+      specify { expect { city.update_attributes!(country: nil) }.to update_index('countries#country').and_reindex(country1).only }
 
-      specify { expect { city.update_attributes!(country: country2) }.to update_index('cities#city').and_reindex(city) }
-      specify { expect { city.update_attributes!(country: country2) }.to update_index('countries#country').and_reindex(country1, country2) }
+      specify { expect { city.update_attributes!(country: country2) }.to update_index('cities#city').and_reindex(city).only }
+      specify { expect { city.update_attributes!(country: country2) }.to update_index('countries#country').and_reindex(country1, country2).only }
     end
 
     context do
@@ -86,8 +86,8 @@ describe Chewy::Type::Import do
         end
       end
 
-      specify { expect { country.save! }.to update_index('cities#city').and_reindex(country.cities) }
-      specify { expect { country.save! }.to update_index('countries#country').and_reindex(country) }
+      specify { expect { country.save! }.to update_index('cities#city').and_reindex(country.cities).only }
+      specify { expect { country.save! }.to update_index('countries#country').and_reindex(country).only }
 
       context 'conditional update' do
         let(:update_condition) { false }

data/spec/chewy/type/witchcraft_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+
+describe Chewy::Type::Witchcraft do
+  def self.mapping(&block)
+    before do
+      stub_index(:products) do
+        define_type :product do
+          witchcraft!
+
+          instance_exec(&block)
+        end
+      end
+    end
+  end
+
+  describe '#cauldron' do
+    let(:type) { ProductsIndex::Product }
+    let(:object) { }
+
+    context 'empty mapping' do
+      mapping {}
+      specify { expect(type.cauldron.brew(object)).to eq({}) }
+    end
+
+    context do
+      mapping do
+        field :name
+        field :age
+        field :tags
+      end
+      let(:attributes) { { name: 'Name', age: 13, tags: %w[Ruby RoR] } }
+
+      context do
+        let(:object) { double(attributes) }
+        specify { expect(type.cauldron.brew(object)).to eq(attributes.as_json) }
+      end
+
+      context do
+        let(:object) { attributes }
+        specify { expect(type.cauldron.brew(object)).to eq(attributes.as_json) }
+      end
+    end
+
+    context 'simple lambdas' do
+      mapping do
+        field :name
+        field :age, value: -> (obj) {
+          obj.age if obj
+        }
+        field :tags, value: -> { tags.map(&:to_sym) }
+      end
+      let(:attributes) { { name: 'Name', age: 13, tags: %w[Ruby RoR] } }
+
+      context do
+        let(:object) { double(attributes) }
+        specify { expect(type.cauldron.brew(object)).to eq(attributes.merge(tags: [:Ruby, :RoR]).as_json) }
+      end
+    end
+
+    context 'crutches' do
+      mapping do
+        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) }
+      end
+    end
+
+    context 'nesting' do
+      context do
+        mapping do
+          field :queries do
+            field :title
+            field :body, value: -> { "This #{self[:body]}" }
+          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) }
+      end
+
+      context do
+        mapping do
+          field :queries do
+            field :title
+            field :body, value: -> { "This #{body}" }
+          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) }
+      end
+
+      context do
+        mapping do
+          field :queries, value: -> { queries } do
+            field :title
+            field :body, value: -> { "This #{body}" }
+          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) }
+      end
+
+      context do
+        mapping do
+          field :queries do
+            field :fields, value: -> (o, q) { q.fields } do
+              field :first
+              field :second, value: -> (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) }
+      end
+    end
+  end
+end

data/spec/chewy/type/wrapper_spec.rb

@@ -10,12 +10,37 @@ describe Chewy::Type::Wrapper do
 
   let(:city_type) { CitiesIndex::City }
 
-  subject { city_type.new(name: 'Martin', age: 42) }
+  subject(:city) { city_type.new(name: 'Martin', age: 42) }
 
-  it { is_expected.to respond_to :name }
-  it { is_expected.to respond_to :age }
-  its(:name) { should == 'Martin' }
-  its(:age) { should == 42 }
+  it do
+    is_expected.to respond_to(:name)
+      .and respond_to(:age)
+      .and have_attributes(
+        name: 'Martin',
+        age: 42
+      )
+  end
+
+  it { expect { city.population }.to raise_error(NoMethodError) }
+
+  context 'highlight' do
+    subject(:city) do
+      city_type.new(name: 'Martin', age: 42)
+        .tap do |city|
+          city._data = {
+            'highlight' => { 'name' => ['<b>Mar</b>tin'] }
+          }
+        end
+    end
+
+    it do
+      is_expected.to respond_to(:name_highlight)
+        .and have_attributes(
+          name: 'Martin',
+          name_highlight: '<b>Mar</b>tin'
+        )
+    end
+  end
 
   describe '#==' do
     specify { expect(city_type.new(id: 42)).to eq(city_type.new(id: 42)) }

data/spec/chewy/type_spec.rb

@@ -19,5 +19,15 @@ describe Chewy::Type do
 
     specify { expect(described_class.scopes).to eq([]) }
     specify { expect(PlacesIndex::City.scopes).to match_array([:by_rating, :by_name]) }
+    specify { expect { PlacesIndex::City.non_existing_method_call }.to raise_error(NoMethodError) }
+
+    specify { expect(PlacesIndex::City._default_import_options).to eq({}) }
+    specify { expect { PlacesIndex::City.default_import_options(invalid_option: "Yeah!") }.to raise_error(ArgumentError) }
+
+    context 'default_import_options is set' do
+      before { PlacesIndex::City.default_import_options(batch_size: 500) }
+
+      specify { expect(PlacesIndex::City._default_import_options).to eq(batch_size: 500) }
+    end
   end
 end

data/spec/chewy_spec.rb

@@ -25,11 +25,11 @@ describe Chewy do
     specify { expect { described_class.derive_type('developers#borogoves') }.to raise_error Chewy::UnderivableType, /DevelopersIndex.*borogoves/ }
     specify { expect { described_class.derive_type('namespace/autocomplete') }.to raise_error Chewy::UnderivableType, /AutocompleteIndex.*namespace\/autocomplete#type_name/ }
 
-    specify { expect(described_class.derive_type(DevelopersIndex.developer)).to eq(DevelopersIndex.developer) }
-    specify { expect(described_class.derive_type('developers')).to eq(DevelopersIndex.developer) }
-    specify { expect(described_class.derive_type('developers#developer')).to eq(DevelopersIndex.developer) }
-    specify { expect(described_class.derive_type('namespace/autocomplete#developer')).to eq(Namespace::AutocompleteIndex.developer) }
-    specify { expect(described_class.derive_type('namespace/autocomplete#company')).to eq(Namespace::AutocompleteIndex.company) }
+    specify { expect(described_class.derive_type(DevelopersIndex::Developer)).to eq(DevelopersIndex::Developer) }
+    specify { expect(described_class.derive_type('developers')).to eq(DevelopersIndex::Developer) }
+    specify { expect(described_class.derive_type('developers#developer')).to eq(DevelopersIndex::Developer) }
+    specify { expect(described_class.derive_type('namespace/autocomplete#developer')).to eq(Namespace::AutocompleteIndex::Developer) }
+    specify { expect(described_class.derive_type('namespace/autocomplete#company')).to eq(Namespace::AutocompleteIndex::Company) }
   end
 
   describe '.create_type' do
@@ -110,4 +110,28 @@ describe Chewy do
     specify { expect(DevelopersIndex.exists?).to eq(false) }
     specify { expect(CompaniesIndex.exists?).to eq(false) }
   end
+
+  describe '.client' do
+    let!(:initial_client) { Thread.current[:chewy_client] }
+    let(:faraday_block) { proc { } }
+    let(:mock_client) { double(:client) }
+    let(:expected_client_config) { { transport_options: {} } }
+
+    before do
+      Thread.current[:chewy_client] = nil
+      allow(Chewy).to receive_messages(configuration: { transport_options: { proc: faraday_block } })
+
+      allow(::Elasticsearch::Client).to receive(:new).with(expected_client_config) do |*args, &passed_block|
+        # RSpec's `with(…, &block)` was used previously, but doesn't actually do
+        # any verification of the passed block (even of its presence).
+        expect(passed_block.source_location).to eq(faraday_block.source_location)
+
+        mock_client
+      end
+    end
+
+    its(:client) { is_expected.to eq(mock_client) }
+
+    after { Thread.current[:chewy_client] = initial_client }
+  end
 end