chewy 7.1.0 → 7.2.0

data/spec/chewy/index/wrapper_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe Chewy::Index::Wrapper do
+  before do
+    stub_class(:city)
+    stub_index(:cities) do
+      index_scope City
+    end
+  end
+
+  let(:cities_index) { CitiesIndex }
+
+  describe '.build' do
+    specify do
+      expect(cities_index.build({}).attributes)
+        .to eq('id' => nil, '_score' => nil, '_explanation' => nil)
+    end
+    specify do
+      expect(cities_index.build('_source' => {name: 'Martin'}).attributes)
+        .to eq('id' => nil, '_score' => nil, '_explanation' => nil, 'name' => 'Martin')
+    end
+    specify do
+      expect(cities_index.build('_id' => 42).attributes)
+        .to eq('id' => 42, '_score' => nil, '_explanation' => nil)
+    end
+    specify do
+      expect(cities_index.build('_id' => 42, '_source' => {'id' => 43}).attributes)
+        .to eq('id' => 43, '_score' => nil, '_explanation' => nil)
+    end
+    specify do
+      expect(cities_index.build('_score' => 42, '_explanation' => {foo: 'bar'}).attributes)
+        .to eq('id' => nil, '_score' => 42, '_explanation' => {foo: 'bar'})
+    end
+    specify do
+      expect(cities_index.build('_score' => 42, 'borogoves' => {foo: 'bar'})._data)
+        .to eq('_score' => 42, 'borogoves' => {foo: 'bar'})
+    end
+  end
+
+  describe '#initialize' do
+    subject(:city) { cities_index.new(name: 'Martin', age: 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
+        cities_index.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 respond_to(:name_highlights)
+          .and have_attributes(
+            name: 'Martin',
+            name_highlight: '<b>Mar</b>tin',
+            name_highlights: ['<b>Mar</b>tin']
+          )
+      end
+    end
+  end
+
+  describe '#==' do
+    specify { expect(cities_index.new(id: 42)).to eq(cities_index.new(id: 42)) }
+    specify { expect(cities_index.new(id: 42, age: 55)).to eq(cities_index.new(id: 42, age: 54)) }
+    specify { expect(cities_index.new(id: 42)).not_to eq(cities_index.new(id: 43)) }
+    specify { expect(cities_index.new(id: 42, age: 55)).not_to eq(cities_index.new(id: 43, age: 55)) }
+    specify { expect(cities_index.new(age: 55)).to eq(cities_index.new(age: 55)) }
+    specify { expect(cities_index.new(age: 55)).not_to eq(cities_index.new(age: 54)) }
+
+    specify { expect(cities_index.new(id: '42')).to eq(City.new.tap { |m| allow(m).to receive_messages(id: 42) }) }
+    specify { expect(cities_index.new(id: 42)).not_to eq(City.new.tap { |m| allow(m).to receive_messages(id: 43) }) }
+    specify { expect(cities_index.new(id: 42)).not_to eq(Class.new) }
+
+    context 'models', :orm do
+      before do
+        stub_model(:city)
+        stub_index(:cities) do
+          index_scope City
+        end
+      end
+      specify { expect(cities_index.new(id: '42')).to eq(City.new.tap { |m| allow(m).to receive_messages(id: 42) }) }
+      specify { expect(cities_index.new(id: 42)).not_to eq(City.new.tap { |m| allow(m).to receive_messages(id: 43) }) }
+      specify { expect(cities_index.new(id: 42)).not_to eq(Class.new) }
+    end
+  end
+end

data/spec/chewy/index_spec.rb

@@ -2,9 +2,7 @@ require 'spec_helper'
 
 describe Chewy::Index do
   before do
-    stub_index(:dummies) do
-      define_type :dummy
-    end
+    stub_index(:dummies)
   end
 
   describe '.import', :orm do
@@ -13,11 +11,11 @@ describe Chewy::Index do
       stub_model(:country)
 
       stub_index(:cities) do
-        define_type City
+        index_scope City
       end
 
       stub_index(:countries) do
-        define_type Country
+        index_scope Country
       end
     end
 
@@ -30,18 +28,13 @@ describe Chewy::Index do
     end
 
     specify do
-      expect { CitiesIndex.import city: cities.first }.to update_index(CitiesIndex).and_reindex(cities.first).only
-      expect { CountriesIndex.import city: cities.first }.to update_index(CountriesIndex).and_reindex(countries)
-    end
-
-    specify do
-      expect { CitiesIndex.import city: cities.first, country: countries.last }.to update_index(CitiesIndex).and_reindex(cities.first).only
-      expect { CountriesIndex.import city: cities.first, country: countries.last }.to update_index(CountriesIndex).and_reindex(countries.last).only
+      expect { CitiesIndex.import cities.first }.to update_index(CitiesIndex).and_reindex(cities.first).only
+      expect { CountriesIndex.import countries.last }.to update_index(CountriesIndex).and_reindex(countries.last).only
     end
 
     specify do
       expect(CitiesIndex.client).to receive(:bulk).with(hash_including(refresh: false)).once
-      CitiesIndex.import city: cities.first, refresh: false
+      CitiesIndex.import cities.first, refresh: false
     end
   end
 
@@ -64,10 +57,18 @@ describe Chewy::Index do
     specify { expect(stub_const('DeveloperIndex', Class.new(Chewy::Index)).index_name).to eq('developer') }
     specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name).to eq('developers') }
 
-    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name(suffix: '')).to eq('developers') }
-    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name(suffix: '2013')).to eq('developers_2013') }
-    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name(prefix: '')).to eq('developers') }
-    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name(prefix: 'test')).to eq('test_developers') }
+    specify do
+      expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name(suffix: '')).to eq('developers')
+    end
+    specify do
+      expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name(suffix: '2013')).to eq('developers_2013')
+    end
+    specify do
+      expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name(prefix: '')).to eq('developers')
+    end
+    specify do
+      expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name(prefix: 'test')).to eq('test_developers')
+    end
 
     context do
       before { allow(Chewy).to receive_messages(configuration: {prefix: 'testing'}) }
@@ -88,18 +89,18 @@ describe Chewy::Index do
     specify { expect(Class.new(Chewy::Index).prefix).to eq('testing') }
   end
 
-  describe '.define_type' do
-    specify { expect(DummiesIndex.type_hash['dummy']).to eq(DummiesIndex::Dummy) }
+  describe '.index_scope' do
+    specify { expect(DummiesIndex.adapter.name).to eq('Default') }
 
     context do
-      before { stub_index(:dummies) { define_type :dummy, name: :borogoves } }
-      specify { expect(DummiesIndex.type_hash['borogoves']).to eq(DummiesIndex::Borogoves) }
+      before { stub_index(:dummies) { index_scope :dummy, name: :borogoves } }
+      specify { expect(DummiesIndex.adapter.name).to eq('Borogoves') }
     end
 
     context do
       before { stub_class(:city) }
-      before { stub_index(:dummies) { define_type City, name: :country } }
-      specify { expect(DummiesIndex.type_hash['country']).to eq(DummiesIndex::Country) }
+      before { stub_index(:dummies) { index_scope City, name: :country } }
+      specify { expect(DummiesIndex.adapter.name).to eq('Country') }
     end
 
     context do
@@ -110,16 +111,16 @@ describe Chewy::Index do
         expect do
           Kernel.eval <<-DUMMY_CITY_INDEX
             class DummyCityIndex2 < Chewy::Index
-              define_type City
-              define_type Country
+              index_scope City
+              index_scope Country
             end
           DUMMY_CITY_INDEX
-        end.to raise_error(/Multiple types are deprecated/)
+        end.to raise_error(/Index scope is already defined/)
 
         expect do
           Kernel.eval <<-DUMMY_CITY_INDEX
             class DummyCityIndex2 < Chewy::Index
-              define_type City::Nothing
+              index_scope City::Nothing
             end
           DUMMY_CITY_INDEX
         end.to raise_error(NameError)
@@ -127,24 +128,6 @@ describe Chewy::Index do
     end
   end
 
-  describe '.type_hash' do
-    specify { expect(DummiesIndex.type_hash['dummy']).to eq(DummiesIndex::Dummy) }
-    specify { expect(DummiesIndex.type_hash).to have_key 'dummy' }
-    specify { expect(DummiesIndex.type_hash['dummy']).to be < Chewy::Type }
-    specify { expect(DummiesIndex.type_hash['dummy'].type_name).to eq('dummy') }
-  end
-
-  describe '.type' do
-    specify { expect(DummiesIndex.type('dummy')).to eq(DummiesIndex::Dummy) }
-    specify { expect { DummiesIndex.type('not-the-dummy') }.to raise_error(Chewy::UndefinedType) }
-  end
-
-  specify { expect(DummiesIndex.type_names).to eq(DummiesIndex.type_hash.keys) }
-
-  describe '.types' do
-    specify { expect(DummiesIndex.types).to eq(DummiesIndex.type_hash.values) }
-  end
-
   describe '.settings' do
     before do
       allow(Chewy).to receive_messages(config: Chewy::Config.send(:new))
@@ -156,7 +139,11 @@ describe Chewy::Index do
       Chewy.filter :names_nysiis, type: 'phonetic', encoder: 'nysiis', replace: false
     end
 
-    let(:documents) { stub_index(:documents) { settings analysis: {analyzer: [:name, :phone, {sorted: {option: :baz}}]} } }
+    let(:documents) do
+      stub_index(:documents) do
+        settings analysis: {analyzer: [:name, :phone, {sorted: {option: :baz}}]}
+      end
+    end
 
     specify { expect { documents.settings_hash }.to_not change(documents._settings, :inspect) }
     specify do
@@ -180,20 +167,18 @@ describe Chewy::Index do
           filter(terms: {colors: colors.flatten(1).map(&:to_s)})
         end
 
-        define_type :city do
-          def self.by_id; end
-          field :colors
-        end
+        def self.by_id; end
+        field :colors
       end
     end
 
     specify { expect(described_class.scopes).to eq([]) }
-    specify { expect(PlacesIndex.scopes).to match_array(%i[by_rating colors]) }
+    specify { expect(PlacesIndex.scopes).to match_array(%i[by_rating colors by_id]) }
 
     context do
       before do
         Chewy.massacre
-        PlacesIndex::City.import!(
+        PlacesIndex.import!(
           double(colors: ['red']),
           double(colors: %w[red green]),
           double(colors: %w[green yellow])
@@ -201,16 +186,12 @@ describe Chewy::Index do
       end
 
       specify do
-        # This `blank?`` call is for the messed scopes bug reproduction. See #573
-        PlacesIndex::City.blank?
         expect(PlacesIndex.colors(:green).map(&:colors))
           .to contain_exactly(%w[red green], %w[green yellow])
       end
 
       specify do
-        # This `blank?` call is for the messed scopes bug reproduction. See #573
-        PlacesIndex::City.blank?
-        expect(PlacesIndex::City.colors(:green).map(&:colors))
+        expect(PlacesIndex.colors(:green).map(&:colors))
           .to contain_exactly(%w[red green], %w[green yellow])
       end
     end
@@ -220,17 +201,19 @@ describe Chewy::Index do
     before { allow(Chewy).to receive_messages(config: Chewy::Config.send(:new)) }
 
     specify { expect(stub_index(:documents).settings_hash).to eq({}) }
-    specify { expect(stub_index(:documents) { settings number_of_shards: 1 }.settings_hash).to eq(settings: {number_of_shards: 1}) }
+    specify do
+      expect(stub_index(:documents) do
+               settings number_of_shards: 1
+             end.settings_hash).to eq(settings: {number_of_shards: 1})
+    end
   end
 
   describe '.mappings_hash' do
     specify { expect(stub_index(:documents).mappings_hash).to eq({}) }
-    specify { expect(stub_index(:documents) { define_type :document }.mappings_hash).to eq({}) }
+    specify { expect(stub_index(:documents) { index_scope :document }.mappings_hash).to eq({}) }
     specify do
       expect(stub_index(:documents) do
-               define_type :document do
-                 field :date, type: 'date'
-               end
+               field :date, type: 'date'
              end.mappings_hash).to eq(mappings: {properties: {date: {type: 'date'}}})
     end
   end
@@ -239,20 +222,20 @@ describe Chewy::Index do
     before { allow(Chewy).to receive_messages(config: Chewy::Config.send(:new)) }
 
     specify { expect(stub_index(:documents).specification_hash).to eq({}) }
-    specify { expect(stub_index(:documents) { settings number_of_shards: 1 }.specification_hash.keys).to eq([:settings]) }
     specify do
       expect(stub_index(:documents) do
-               define_type :document do
-                 field :name
-               end
+               settings number_of_shards: 1
+             end.specification_hash.keys).to eq([:settings])
+    end
+    specify do
+      expect(stub_index(:documents) do
+               field :name
              end.specification_hash.keys).to eq([:mappings])
     end
     specify do
       expect(stub_index(:documents) do
                settings number_of_shards: 1
-               define_type :document do
-                 field :name
-               end
+               field :name
              end.specification_hash.keys).to match_array(%i[mappings settings])
     end
   end
@@ -263,50 +246,24 @@ describe Chewy::Index do
     specify { expect(subject.specification).to equal(subject.specification) }
   end
 
-  describe '.default_prefix' do
-    before { allow(Chewy).to receive_messages(configuration: {prefix: 'testing'}) }
-
-    context do
-      before { expect(ActiveSupport::Deprecation).to receive(:warn).once }
-      specify { expect(DummiesIndex.default_prefix).to eq('testing') }
-    end
-
-    context do
-      before do
-        DummiesIndex.class_eval do
-          def self.default_prefix
-            'borogoves'
-          end
-        end
-      end
-
-      before { expect(ActiveSupport::Deprecation).to receive(:warn).once }
-      specify { expect(DummiesIndex.index_name).to eq('borogoves_dummies') }
-    end
-  end
-
   context 'index call inside index', :orm do
     before do
       stub_index(:cities) do
-        define_type :city do
-          field :country_name, value: (lambda do |city|
-            CountriesIndex::Country.filter(term: {_id: city.country_id}).first.name
-          end)
-        end
+        field :country_name, value: (lambda do |city|
+          CountriesIndex.filter(term: {_id: city.country_id}).first.name
+        end)
       end
 
       stub_index(:countries) do
-        define_type :country do
-          field :name
-        end
+        field :name
       end
 
-      CountriesIndex::Country.import!(double(id: 1, name: 'Country'))
+      CountriesIndex.import!(double(id: 1, name: 'Country'))
     end
 
     specify do
-      expect { CitiesIndex::City.import!(double(country_id: 1)) }
-        .to update_index(CitiesIndex::City).and_reindex(country_name: 'Country')
+      expect { CitiesIndex.import!(double(country_id: 1)) }
+        .to update_index(CitiesIndex).and_reindex(country_name: 'Country')
     end
   end
 end

data/spec/chewy/journal_spec.rb

@@ -13,14 +13,12 @@ describe Chewy::Journal do
           end
 
           stub_index("#{namespace}cities") do
-            define_type City do
-              default_import_options journal: true
-            end
+            index_scope City
+            default_import_options journal: true
           end
           stub_index("#{namespace}countries") do
-            define_type Country do
-              default_import_options journal: true
-            end
+            index_scope Country
+            default_import_options journal: true
           end
 
           Chewy.massacre
@@ -67,63 +65,54 @@ describe Chewy::Journal do
             expected_journal = [
               {
                 'index_name' => "#{namespace}cities",
-                'type_name' => 'city',
                 'action' => 'index',
                 'references' => ['1'].map(&Base64.method(:encode64)),
                 'created_at' => time.utc.as_json
               },
               {
                 'index_name' => "#{namespace}cities",
-                'type_name' => 'city',
                 'action' => 'index',
                 'references' => ['2'].map(&Base64.method(:encode64)),
                 'created_at' => time.utc.as_json
               },
               {
                 'index_name' => "#{namespace}countries",
-                'type_name' => 'country',
                 'action' => 'index',
                 'references' => ['1'].map(&Base64.method(:encode64)),
                 'created_at' => time.utc.as_json
               },
               {
                 'index_name' => "#{namespace}countries",
-                'type_name' => 'country',
                 'action' => 'index',
                 'references' => ['2'].map(&Base64.method(:encode64)),
                 'created_at' => time.utc.as_json
               },
               {
                 'index_name' => "#{namespace}countries",
-                'type_name' => 'country',
                 'action' => 'index',
                 'references' => ['3'].map(&Base64.method(:encode64)),
                 'created_at' => time.utc.as_json
               },
               {
                 'index_name' => "#{namespace}cities",
-                'type_name' => 'city',
                 'action' => 'index',
                 'references' => %w[1 2].map(&Base64.method(:encode64)),
                 'created_at' => import_time.utc.as_json
               },
               {
                 'index_name' => "#{namespace}countries",
-                'type_name' => 'country',
                 'action' => 'index',
                 'references' => %w[1 2 3].map(&Base64.method(:encode64)),
                 'created_at' => import_time.utc.as_json
               },
               {
                 'index_name' => "#{namespace}cities",
-                'type_name' => 'city',
                 'action' => 'index',
                 'references' => ['1'].map(&Base64.method(:encode64)),
                 'created_at' => update_time.utc.as_json
               },
               {
                 'index_name' => "#{namespace}countries",
-                'type_name' => 'country',
                 'action' => 'delete',
                 'references' => ['2'].map(&Base64.method(:encode64)),
                 'created_at' => destroy_time.utc.as_json
@@ -166,14 +155,12 @@ describe Chewy::Journal do
       end
 
       stub_index(:cities) do
-        define_type City do
-          default_import_options journal: true
-        end
+        index_scope City
+        default_import_options journal: true
       end
       stub_index(:countries) do
-        define_type Country do
-          default_import_options journal: true
-        end
+        index_scope Country
+        default_import_options journal: true
       end
     end
 
@@ -235,7 +222,7 @@ describe Chewy::Journal do
           let!(:journal_entries) do
             record = Chewy::Stash::Journal.entries(time).first
             Array.new(count_of_checks) do |i|
-              Chewy::Stash::Journal::Journal.new(
+              Chewy::Stash::Journal.new(
                 record.attributes.merge(
                   'created_at' => time.to_i + i,
                   'references' => [i.to_s]