chewy 0.10.1 → 7.3.2

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
@@ -12,9 +10,12 @@ describe Chewy::Index do
       stub_model(:city)
       stub_model(:country)
 
-      stub_index(:places) do
-        define_type City
-        define_type Country
+      stub_index(:cities) do
+        index_scope City
+      end
+
+      stub_index(:countries) do
+        index_scope Country
       end
     end
 
@@ -22,23 +23,18 @@ describe Chewy::Index do
     let!(:countries) { Array.new(2) { |i| Country.create! id: i + 1 } }
 
     specify do
-      expect { PlacesIndex.import }.to update_index(PlacesIndex::City).and_reindex(cities)
-      expect { PlacesIndex.import }.to update_index(PlacesIndex::Country).and_reindex(countries)
+      expect { CitiesIndex.import }.to update_index(CitiesIndex).and_reindex(cities)
+      expect { CountriesIndex.import }.to update_index(CountriesIndex).and_reindex(countries)
     end
 
     specify do
-      expect { PlacesIndex.import city: cities.first }.to update_index(PlacesIndex::City).and_reindex(cities.first).only
-      expect { PlacesIndex.import city: cities.first }.to update_index(PlacesIndex::Country).and_reindex(countries)
+      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 { PlacesIndex.import city: cities.first, country: countries.last }.to update_index(PlacesIndex::City).and_reindex(cities.first).only
-      expect { PlacesIndex.import city: cities.first, country: countries.last }.to update_index(PlacesIndex::Country).and_reindex(countries.last).only
-    end
-
-    specify do
-      expect(PlacesIndex.client).to receive(:bulk).with(hash_including(refresh: false)).twice
-      PlacesIndex.import city: cities.first, refresh: false
+      expect(CitiesIndex.client).to receive(:bulk).with(hash_including(refresh: false)).once
+      CitiesIndex.import cities.first, refresh: false
     end
   end
 
@@ -61,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'}) }
@@ -85,79 +89,43 @@ 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
       before { stub_class('City') }
-      before { stub_class('City::District', City) }
+      before { stub_class('Country') }
 
       specify do
         expect do
           Kernel.eval <<-DUMMY_CITY_INDEX
-            class DummyCityIndex < Chewy::Index
-              define_type City
-              define_type City::District
+            class DummyCityIndex2 < Chewy::Index
+              index_scope City
+              index_scope Country
             end
           DUMMY_CITY_INDEX
-        end.not_to raise_error
-      end
+        end.to raise_error(/Index scope is already defined/)
 
-      specify do
         expect do
           Kernel.eval <<-DUMMY_CITY_INDEX
             class DummyCityIndex2 < Chewy::Index
-              define_type City
-              define_type City::Nothing
+              index_scope City::Nothing
             end
           DUMMY_CITY_INDEX
         end.to raise_error(NameError)
       end
     end
-
-    context 'type methods should be deprecated and can\'t redefine existing ones' do
-      before do
-        stub_index(:places) do
-          def self.city; end
-          define_type :city
-          define_type :country
-        end
-      end
-
-      specify { expect(PlacesIndex.city).to be_nil }
-      specify { expect(PlacesIndex::Country).to be < Chewy::Type }
-    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) }
-    specify { expect(DummiesIndex.types(:dummy)).to be_a Chewy::Search::Request }
-    specify { expect(DummiesIndex.types(:user)).to be_a Chewy::Search::Request }
   end
 
   describe '.settings' do
@@ -171,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
@@ -191,44 +163,58 @@ describe Chewy::Index do
       stub_index(:places) do
         def self.by_rating; end
 
-        def self.by_name; end
-
-        define_type :city do
-          def self.by_id; end
+        def self.colors(*colors)
+          filter(terms: {colors: colors.flatten(1).map(&:to_s)})
         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 by_name]) }
+    specify { expect(PlacesIndex.scopes).to match_array(%i[by_rating colors by_id]) }
+
+    context do
+      before do
+        Chewy.massacre
+        PlacesIndex.import!(
+          double(colors: ['red']),
+          double(colors: %w[red green]),
+          double(colors: %w[green yellow])
+        )
+      end
+
+      specify do
+        expect(PlacesIndex.colors(:green).map(&:colors))
+          .to contain_exactly(%w[red green], %w[green yellow])
+      end
+
+      specify do
+        expect(PlacesIndex.colors(:green).map(&:colors))
+          .to contain_exactly(%w[red green], %w[green yellow])
+      end
+    end
   end
 
   describe '.settings_hash' 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 do
-      expect(stub_index(:documents) do
-               define_type :document do
-                 field :name, type: 'string'
-               end
-             end.mappings_hash).to eq(mappings: {document: {properties: {name: {type: 'string'}}}})
-    end
+    specify { expect(stub_index(:documents) { index_scope :document }.mappings_hash).to eq({}) }
     specify do
       expect(stub_index(:documents) do
-               define_type :document do
-                 field :name, type: 'string'
-               end
-               define_type :document2 do
-                 field :name, type: 'string'
-               end
-             end.mappings_hash[:mappings].keys).to match_array(%i[document document2])
+               field :date, type: 'date'
+             end.mappings_hash).to eq(mappings: {properties: {date: {type: 'date'}}})
     end
   end
 
@@ -236,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, type: 'string'
-               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, type: 'string'
-               end
+               field :name
              end.specification_hash.keys).to match_array(%i[mappings settings])
     end
   end
@@ -260,25 +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 'index call inside index', :orm do
+    before do
+      stub_index(:cities) do
+        field :country_name, value: (lambda do |city|
+          CountriesIndex.filter(term: {_id: city.country_id}).first.name
+        end)
+      end
 
-    context do
-      before do
-        DummiesIndex.class_eval do
-          def self.default_prefix
-            'borogoves'
-          end
-        end
+      stub_index(:countries) do
+        field :name
       end
 
-      before { expect(ActiveSupport::Deprecation).to receive(:warn).once }
-      specify { expect(DummiesIndex.index_name).to eq('borogoves_dummies') }
+      CountriesIndex.import!(double(id: 1, name: 'Country'))
+    end
+
+    specify do
+      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

@@ -6,19 +6,19 @@ describe Chewy::Journal do
       context namespace.present? ? 'with namespace' : 'without namespace' do
         before do
           stub_model(:city) do
-            update_index "#{namespace}places#city", :self
+            update_index "#{namespace}cities", :self
           end
           stub_model(:country) do
-            update_index "#{namespace}places#country", :self
+            update_index "#{namespace}countries", :self
           end
 
-          stub_index("#{namespace}places") do
-            define_type City do
-              default_import_options journal: true
-            end
-            define_type Country do
-              default_import_options journal: true
-            end
+          stub_index("#{namespace}cities") do
+            index_scope City
+            default_import_options journal: true
+          end
+          stub_index("#{namespace}countries") do
+            index_scope Country
+            default_import_options journal: true
           end
 
           Chewy.massacre
@@ -41,7 +41,8 @@ describe Chewy::Journal do
         end
 
         specify do
-          places_index = namespace.present? ? Namespace::PlacesIndex : PlacesIndex
+          cities_index = namespace.present? ? Namespace::CitiesIndex : CitiesIndex
+          countries_index = namespace.present? ? Namespace::CountriesIndex : CountriesIndex
           Chewy.strategy(:urgent) do
             cities = Array.new(2) { |i| City.create!(id: i + 1) }
             countries = Array.new(2) { |i| Country.create!(id: i + 1) }
@@ -49,12 +50,13 @@ describe Chewy::Journal do
 
             Timecop.freeze(import_time)
 
-            places_index.import
+            cities_index.import
+            countries_index.import
 
-            expect(Chewy::Stash.exists?).to eq true
+            expect(Chewy::Stash::Journal.exists?).to eq true
 
             Timecop.freeze(update_time)
-            cities.first.update_attributes!(name: 'Supername')
+            cities.first.update!(name: 'Supername')
 
             Timecop.freeze(destroy_time)
             countries.last.destroy
@@ -62,66 +64,57 @@ describe Chewy::Journal do
             journal_entries = Chewy::Stash::Journal.order(:created_at).hits.map { |r| r['_source'] }
             expected_journal = [
               {
-                'index_name' => "#{namespace}places",
-                'type_name' => 'city',
+                'index_name' => "#{namespace}cities",
                 'action' => 'index',
-                'references' => ['1'],
+                'references' => ['1'].map(&Base64.method(:encode64)),
                 'created_at' => time.utc.as_json
               },
               {
-                'index_name' => "#{namespace}places",
-                'type_name' => 'city',
+                'index_name' => "#{namespace}cities",
                 'action' => 'index',
-                'references' => ['2'],
+                'references' => ['2'].map(&Base64.method(:encode64)),
                 'created_at' => time.utc.as_json
               },
               {
-                'index_name' => "#{namespace}places",
-                'type_name' => 'country',
+                'index_name' => "#{namespace}countries",
                 'action' => 'index',
-                'references' => ['1'],
+                'references' => ['1'].map(&Base64.method(:encode64)),
                 'created_at' => time.utc.as_json
               },
               {
-                'index_name' => "#{namespace}places",
-                'type_name' => 'country',
+                'index_name' => "#{namespace}countries",
                 'action' => 'index',
-                'references' => ['2'],
+                'references' => ['2'].map(&Base64.method(:encode64)),
                 'created_at' => time.utc.as_json
               },
               {
-                'index_name' => "#{namespace}places",
-                'type_name' => 'country',
+                'index_name' => "#{namespace}countries",
                 'action' => 'index',
-                'references' => ['3'],
+                'references' => ['3'].map(&Base64.method(:encode64)),
                 'created_at' => time.utc.as_json
               },
               {
-                'index_name' => "#{namespace}places",
-                'type_name' => 'city',
+                'index_name' => "#{namespace}cities",
                 'action' => 'index',
-                'references' => %w[1 2],
+                'references' => %w[1 2].map(&Base64.method(:encode64)),
                 'created_at' => import_time.utc.as_json
               },
               {
-                'index_name' => "#{namespace}places",
-                'type_name' => 'country',
+                'index_name' => "#{namespace}countries",
                 'action' => 'index',
-                'references' => %w[1 2 3],
+                'references' => %w[1 2 3].map(&Base64.method(:encode64)),
                 'created_at' => import_time.utc.as_json
               },
               {
-                'index_name' => "#{namespace}places",
-                'type_name' => 'city',
+                'index_name' => "#{namespace}cities",
                 'action' => 'index',
-                'references' => ['1'],
+                'references' => ['1'].map(&Base64.method(:encode64)),
                 'created_at' => update_time.utc.as_json
               },
               {
-                'index_name' => "#{namespace}places",
-                'type_name' => 'country',
+                'index_name' => "#{namespace}countries",
                 'action' => 'delete',
-                'references' => ['2'],
+                'references' => ['2'].map(&Base64.method(:encode64)),
                 'created_at' => destroy_time.utc.as_json
               }
             ]
@@ -133,11 +126,11 @@ describe Chewy::Journal do
             expect(journal_entries.size).to eq 4
 
             # simulate lost data
-            Chewy.client.delete(index: "#{Chewy.settings[:prefix]}_places", type: 'city', id: 1, refresh: true)
-            expect(places_index::City.count).to eq 1
+            Chewy.client.delete(index: "#{Chewy.settings[:prefix]}_cities", id: 1, refresh: true)
+            expect(cities_index.count).to eq 1
 
             described_class.new.apply(time)
-            expect(places_index::City.count).to eq 2
+            expect(cities_index.count).to eq 2
 
             clean_response = described_class.new.clean(import_time)
             expect(clean_response['deleted'] || clean_response['_indices']['_all']['deleted']).to eq 7
@@ -162,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
 
@@ -188,8 +179,8 @@ describe Chewy::Journal do
             Array.new(2) { |i| Country.create!(id: i + 1) }
 
             # simulate lost data
-            Chewy.client.delete(index: 'cities', type: 'city', id: 1, refresh: true)
-            Chewy.client.delete(index: 'countries', type: 'country', id: 1, refresh: true)
+            Chewy.client.delete(index: 'cities', id: 1, refresh: true)
+            Chewy.client.delete(index: 'countries', id: 1, refresh: true)
             expect(CitiesIndex.all.to_a.length).to eq 1
             expect(CountriesIndex.all.to_a.length).to eq 1
 
@@ -199,7 +190,7 @@ describe Chewy::Journal do
             expect(CountriesIndex.all.to_a.length).to eq 1
 
             # Replay on both
-            Chewy.client.delete(index: 'cities', type: 'city', id: 1, refresh: true)
+            Chewy.client.delete(index: 'cities', id: 1, refresh: true)
             expect(CitiesIndex.all.to_a.length).to eq 1
             expect(described_class.new(CitiesIndex, CountriesIndex).apply(time)).to eq(4)
             expect(CitiesIndex.all.to_a.length).to eq 2
@@ -208,59 +199,23 @@ describe Chewy::Journal do
         end
       end
 
-      context 'retries' do
-        let(:time) { Time.now.to_i }
-        before do
-          Timecop.freeze
-          Chewy.strategy(:urgent)
-          City.create!(id: 1)
-        end
-
-        after do
-          Chewy.strategy.pop
-          Timecop.return
-        end
-
-        specify 'journal was cleaned after the first call' do
-          expect(Chewy::Stash::Journal).to receive(:entries).exactly(2).and_call_original
-          expect(described_class.new.apply(time)).to eq(1)
-        end
-
-        context 'endless journal' do
-          let(:count_of_checks) { 10 } # default
-          let!(:journal_entries) do
-            record = Chewy::Stash::Journal.entries(time).first
-            Array.new(count_of_checks) do |i|
-              Chewy::Stash::Journal.new(
-                record.attributes.merge(
-                  'created_at' => time.to_i + i,
-                  'references' => [i.to_s]
-                )
-              )
-            end
-          end
-
-          specify '10 retries by default' do
-            expect(Chewy::Stash::Journal)
-              .to receive(:entries).exactly(count_of_checks) { [journal_entries.shift].compact }
-            expect(described_class.new.apply(time)).to eq(10)
-          end
+      context 'when order is not preserved' do
+        let(:time) { Time.now }
 
-          specify 'with :once parameter set' do
-            expect(Chewy::Stash::Journal)
-              .to receive(:entries).exactly(1) { [journal_entries.shift].compact }
-            expect(described_class.new.apply(time, retries: 1)).to eq(1)
+        it 'paginates properly through all items' do
+          Chewy.strategy(:urgent) do
+            Timecop.travel(time + 1.minute) { City.create!(id: 2) }
+            Timecop.travel(time + 3.minute) { City.create!(id: 4) }
+            Timecop.travel(time + 2.minute) { City.create!(id: 1) }
+            Timecop.travel(time + 4.minute) { City.create!(id: 3) }
           end
 
-          context 'with retries parameter set' do
-            let(:retries) { 5 }
+          CitiesIndex.purge!
+          expect(CitiesIndex.all.to_a.length).to eq 0
 
-            specify do
-              expect(Chewy::Stash::Journal)
-                .to receive(:entries).exactly(retries) { [journal_entries.shift].compact }
-              expect(described_class.new.apply(time, retries: retries)).to eq(5)
-            end
-          end
+          # Replay on specific index
+          expect(described_class.new(CitiesIndex).apply(time, fetch_limit: 2)).to eq(4)
+          expect(CitiesIndex.all.to_a.map(&:id).sort).to eq([1, 2, 3, 4])
         end
       end
     end