chewy 7.0.1 → 7.1.0

data/spec/chewy/index_spec.rb

@@ -143,8 +143,6 @@ describe Chewy::Index do
 
   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
@@ -233,7 +231,7 @@ describe Chewy::Index do
                define_type :document do
                  field :date, type: 'date'
                end
-             end.mappings_hash).to eq(mappings: {document: {properties: {date: {type: 'date'}}}})
+             end.mappings_hash).to eq(mappings: {properties: {date: {type: 'date'}}})
     end
   end
 

data/spec/chewy/journal_spec.rb

@@ -137,7 +137,7 @@ describe Chewy::Journal do
             expect(journal_entries.size).to eq 4
 
             # simulate lost data
-            Chewy.client.delete(index: "#{Chewy.settings[:prefix]}_cities", type: 'city', id: 1, refresh: true)
+            Chewy.client.delete(index: "#{Chewy.settings[:prefix]}_cities", id: 1, refresh: true)
             expect(cities_index.count).to eq 1
 
             described_class.new.apply(time)
@@ -192,8 +192,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
 
@@ -203,7 +203,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

data/spec/chewy/runtime_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Chewy::Runtime do
   describe '.version' do
     specify { expect(described_class.version).to be_a(described_class::Version) }
-    specify { expect(described_class.version).to be >= '6.8' }
+    specify { expect(described_class.version).to be >= '7.0' }
     specify { expect(described_class.version).to be < '8.0' }
   end
 end

data/spec/chewy/search/loader_spec.rb

@@ -37,7 +37,6 @@ describe Chewy::Search::Loader do
     specify { expect(subject.derive_type('cities', 'city')).to eq(CitiesIndex::City) }
     specify { expect(subject.derive_type('cities_suffix', 'city')).to eq(CitiesIndex::City) }
 
-    specify { expect { subject.derive_type('cities', 'place') }.to raise_error(Chewy::UnderivableType) }
     specify { expect { subject.derive_type('whatever', 'city') }.to raise_error(Chewy::UnderivableType) }
     specify { expect { subject.derive_type('citiessuffix', 'city') }.to raise_error(Chewy::UnderivableType) }
 
@@ -54,21 +53,6 @@ describe Chewy::Search::Loader do
 
     specify { expect(subject.load(hits)).to eq([*cities, *countries]) }
 
-    context do
-      let(:options) { {only: 'city'} }
-      specify { expect(subject.load(hits)).to eq([*cities, nil, nil]) }
-    end
-
-    context do
-      let(:options) { {except: 'city'} }
-      specify { expect(subject.load(hits)).to eq([nil, nil, *countries]) }
-    end
-
-    context do
-      let(:options) { {except: %w[city country]} }
-      specify { expect(subject.load(hits)).to eq([nil, nil, nil, nil]) }
-    end
-
     context 'scopes', :active_record do
       context do
         let(:options) { {scope: -> { where('rating > 2') }} }

data/spec/chewy/search/parameters/indices_spec.rb

@@ -9,30 +9,32 @@ describe Chewy::Search::Parameters::Indices do
     stub_index(:second) do
       define_type :three
     end
+
+    stub_index(:third)
   end
 
-  subject { described_class.new(indices: FirstIndex, types: SecondIndex::Three) }
+  subject { described_class.new(indices: [FirstIndex, SecondIndex]) }
 
   describe '#initialize' do
-    specify { expect(described_class.new.value).to eq(indices: [], types: []) }
-    specify { expect(described_class.new(nil).value).to eq(indices: [], types: []) }
-    specify { expect(described_class.new(foo: :whatever).value).to eq(indices: [], types: []) }
-    specify { expect(subject.value).to eq(indices: [FirstIndex], types: [SecondIndex::Three]) }
+    specify { expect(described_class.new.value).to eq(indices: []) }
+    specify { expect(described_class.new(nil).value).to eq(indices: []) }
+    specify { expect(described_class.new(foo: :whatever).value).to eq(indices: []) }
+    specify { expect(subject.value).to eq(indices: [FirstIndex, SecondIndex]) }
   end
 
   describe '#replace!' do
     specify do
       expect { subject.replace!(nil) }
         .to change { subject.value }
-        .from(indices: [FirstIndex], types: [SecondIndex::Three])
-        .to(indices: [], types: [])
+        .from(indices: [FirstIndex, SecondIndex])
+        .to(indices: [])
     end
 
     specify do
-      expect { subject.replace!(indices: SecondIndex, types: FirstIndex::One) }
+      expect { subject.replace!(indices: SecondIndex) }
         .to change { subject.value }
-        .from(indices: [FirstIndex], types: [SecondIndex::Three])
-        .to(indices: [SecondIndex], types: [FirstIndex::One])
+        .from(indices: [FirstIndex, SecondIndex])
+        .to(indices: [SecondIndex])
     end
   end
 
@@ -43,10 +45,10 @@ describe Chewy::Search::Parameters::Indices do
     end
 
     specify do
-      expect { subject.update!(indices: SecondIndex, types: [FirstIndex::One, SecondIndex::Three]) }
+      expect { subject.update!(indices: ThirdIndex) }
         .to change { subject.value }
-        .from(indices: [FirstIndex], types: [SecondIndex::Three])
-        .to(indices: [FirstIndex, SecondIndex], types: [SecondIndex::Three, FirstIndex::One])
+        .from(indices: [FirstIndex, SecondIndex])
+        .to(indices: [FirstIndex, SecondIndex, ThirdIndex])
     end
   end
 
@@ -57,10 +59,8 @@ describe Chewy::Search::Parameters::Indices do
     end
 
     specify do
-      expect { subject.merge!(described_class.new(indices: SecondIndex, types: [FirstIndex::One, SecondIndex::Three])) }
-        .to change { subject.value }
-        .from(indices: [FirstIndex], types: [SecondIndex::Three])
-        .to(indices: [FirstIndex, SecondIndex], types: [SecondIndex::Three, FirstIndex::One])
+      expect { subject.merge!(described_class.new(indices: SecondIndex)) }
+        .not_to change { subject.value }
     end
   end
 
@@ -69,7 +69,7 @@ describe Chewy::Search::Parameters::Indices do
     specify do
       expect(described_class.new(
         indices: FirstIndex
-      ).render).to eq(index: %w[first], type: %w[one])
+      ).render).to eq(index: %w[first])
     end
     specify do
       expect(described_class.new(
@@ -78,113 +78,28 @@ describe Chewy::Search::Parameters::Indices do
     end
     specify do
       expect(described_class.new(
-        types: FirstIndex::One
-      ).render).to eq(index: %w[first], type: %w[one])
-    end
-    specify do
-      expect(described_class.new(
-        types: :whatever
-      ).render).to eq({})
-    end
-    specify do
-      expect(described_class.new(
-        indices: FirstIndex, types: SecondIndex::Three
-      ).render).to eq(index: %w[first second], type: %w[one three])
-    end
-    specify do
-      expect(described_class.new(
-        indices: FirstIndex, types: :one
-      ).render).to eq(index: %w[first], type: %w[one])
-    end
-    specify do
-      expect(described_class.new(
-        indices: FirstIndex, types: :whatever
-      ).render).to eq(index: %w[first], type: %w[one])
-    end
-    specify do
-      expect(described_class.new(
-        indices: FirstIndex, types: %i[one whatever]
-      ).render).to eq(index: %w[first], type: %w[one])
-    end
-    specify do
-      expect(described_class.new(
-        indices: :whatever, types: SecondIndex::Three
-      ).render).to eq(index: %w[second whatever], type: %w[three])
-    end
-    specify do
-      expect(described_class.new(
-        indices: :whatever, types: [SecondIndex::Three, :whatever]
-      ).render).to eq(index: %w[second whatever], type: %w[three whatever])
-    end
-    specify do
-      expect(described_class.new(
-        indices: [FirstIndex, :whatever], types: FirstIndex::One
-      ).render).to eq(index: %w[first whatever], type: %w[one])
-    end
-    specify do
-      expect(described_class.new(
-        indices: FirstIndex, types: [FirstIndex::One, :whatever]
-      ).render).to eq(index: %w[first], type: %w[one])
-    end
-    specify do
-      expect(described_class.new(
-        indices: FirstIndex, types: [SecondIndex::Three, :whatever]
-      ).render).to eq(index: %w[first second], type: %w[one three])
-    end
-    specify do
-      expect(described_class.new(
-        indices: [FirstIndex, :whatever], types: [FirstIndex::One, :whatever]
-      ).render).to eq(index: %w[first whatever], type: %w[one whatever])
-    end
-    specify do
-      expect(described_class.new(
-        indices: [FirstIndex, :whatever], types: [SecondIndex::Three, FirstIndex::One]
-      ).render).to eq(index: %w[first second whatever], type: %w[one three])
+        indices: [FirstIndex, :whatever]
+      ).render).to eq(index: %w[first whatever])
     end
   end
 
   describe '#==' do
     specify { expect(described_class.new).to eq(described_class.new) }
     specify do
-      expect(described_class.new(indices: SecondIndex, types: [SecondIndex::Three, :whatever]))
-        .to eq(described_class.new(indices: SecondIndex, types: :whatever))
-    end
-    specify do
-      expect(described_class.new(indices: :first, types: %w[one]))
+      expect(described_class.new(indices: :first))
         .to eq(described_class.new(indices: FirstIndex))
     end
     specify do
-      expect(described_class.new(indices: FirstIndex, types: SecondIndex::Three))
-        .not_to eq(described_class.new(indices: FirstIndex))
+      expect(described_class.new(indices: FirstIndex))
+        .to eq(described_class.new(indices: FirstIndex))
     end
   end
 
   describe '#indices' do
     specify do
       expect(described_class.new(
-        indices: [FirstIndex, :whatever],
-        types: [SecondIndex::Three, :whatever]
-      ).indices).to contain_exactly(FirstIndex, SecondIndex)
-    end
-  end
-
-  describe '#types' do
-    specify do
-      expect(described_class.new(
-        indices: [FirstIndex, :whatever],
-        types: [SecondIndex::Three, :whatever]
-      ).types).to contain_exactly(
-        FirstIndex::One, SecondIndex::Three
-      )
-    end
-
-    specify do
-      expect(described_class.new(
-        indices: [FirstIndex, :whatever],
-        types: [FirstIndex::One, SecondIndex::Three, :whatever]
-      ).types).to contain_exactly(
-        FirstIndex::One, SecondIndex::Three
-      )
+        indices: [FirstIndex, :whatever]
+      ).indices).to contain_exactly(FirstIndex)
     end
   end
 end

data/spec/chewy/search/request_spec.rb

@@ -46,7 +46,6 @@ describe Chewy::Search::Request do
       expect(subject.render)
         .to match(
           index: %w[products],
-          type: array_including(%w[product]),
           body: {}
         )
     end
@@ -55,11 +54,11 @@ describe Chewy::Search::Request do
   describe '#inspect' do
     specify do
       expect(described_class.new(ProductsIndex).inspect)
-        .to eq('<Chewy::Search::Request {:index=>["products"], :type=>["product"], :body=>{}}>')
+        .to eq('<Chewy::Search::Request {:index=>["products"], :body=>{}}>')
     end
     specify do
       expect(ProductsIndex.limit(10).inspect)
-        .to eq('<ProductsIndex::Query {:index=>["products"], :type=>["product"], :body=>{:size=>10}}>')
+        .to eq('<ProductsIndex::Query {:index=>["products"], :body=>{:size=>10}}>')
     end
   end
 
@@ -231,14 +230,6 @@ describe Chewy::Search::Request do
     specify { expect { subject.indices(:cities) }.not_to change { subject.render } }
   end
 
-  describe '#types' do
-    specify { expect(subject.types(:product).render[:type]).to contain_exactly('product') }
-    specify { expect(subject.types(%i[product city]).types(nil).render[:type]).to match_array(%w[product]) }
-    specify { expect(subject.types(:product).types(:product, :city, :something).render[:type]).to match_array(%w[product]) }
-    specify { expect(subject.types(nil).render[:body]).to be_blank }
-    specify { expect { subject.types(:product) }.not_to change { subject.render } }
-  end
-
   describe '#indices_boost' do
     specify { expect(subject.indices_boost(foo: 1.2).render[:body]).to include(indices_boost: [{'foo' => 1.2}]) }
     specify { expect(subject.indices_boost(foo: 1.2).indices_boost(moo: 1.3).render[:body]).to include(indices_boost: [{'foo' => 1.2}, {'moo' => 1.3}]) }
@@ -420,14 +411,10 @@ describe Chewy::Search::Request do
           outer_payload = payload
         end
         subject.query(match: {name: 'name3'}).to_a
-        request = {index: ['products'], type: %w[product], body: {query: {match: {name: 'name3'}}}}
-        request[:rest_total_hits_as_int] = true if Chewy::Runtime.version >= '7.0.0'
         expect(outer_payload).to eq(
           index: ProductsIndex,
           indexes: [ProductsIndex],
-          request: request,
-          type: ProductsIndex::Product,
-          types: [ProductsIndex::Product]
+          request: {index: ['products'], body: {query: {match: {name: 'name3'}}}}
         )
       end
     end
@@ -592,12 +579,12 @@ describe Chewy::Search::Request do
       specify { expect(subject.limit(5).pluck(:_id, :age)).to eq([['1', 10], ['2', 20], ['3', 30], ['4', 40], ['5', 50]]) }
       specify { expect(subject.limit(5).source(:name).pluck(:id, :age)).to eq([[1, 10], [2, 20], [3, 30], [4, 40], [5, 50]]) }
       specify do
-        expect(subject.limit(5).pluck(:_index, :_type, :name)).to eq([
-          %w[products product Name1],
-          %w[products product Name2],
-          %w[products product Name3],
-          %w[products product Name4],
-          %w[products product Name5]
+        expect(subject.limit(5).pluck(:_index, :name)).to eq([
+          %w[products Name1],
+          %w[products Name2],
+          %w[products Name3],
+          %w[products Name4],
+          %w[products Name5]
         ])
       end
 
@@ -644,9 +631,7 @@ describe Chewy::Search::Request do
         expect(outer_payload).to eq(
           index: ProductsIndex,
           indexes: [ProductsIndex],
-          request: {index: ['products'], type: %w[product], body: {query: {match: {name: 'name3'}}}, refresh: true},
-          type: ProductsIndex::Product,
-          types: [ProductsIndex::Product]
+          request: {index: ['products'], body: {query: {match: {name: 'name3'}}}, refresh: true}
         )
       end
 
@@ -659,9 +644,7 @@ describe Chewy::Search::Request do
         expect(outer_payload).to eq(
           index: ProductsIndex,
           indexes: [ProductsIndex],
-          request: {index: ['products'], type: %w[product], body: {query: {match: {name: 'name3'}}}, refresh: false},
-          type: ProductsIndex::Product,
-          types: [ProductsIndex::Product]
+          request: {index: ['products'], body: {query: {match: {name: 'name3'}}}, refresh: false}
         )
       end
     end

data/spec/chewy/search/scrolling_spec.rb

@@ -119,22 +119,16 @@ describe Chewy::Search::Scrolling, :orm do
             outer_payload << payload
           end
           request.scroll_batches(batch_size: 3).to_a
-          request = {index: %w[cities countries], type: %w[city country], body: {sort: ['rating']}, size: 3, scroll: '1m'}
-          request[:rest_total_hits_as_int] = true if Chewy::Runtime.version >= '7.0.0'
           expect(outer_payload).to match_array([
             hash_including(
               index: [CitiesIndex, CountriesIndex],
               indexes: [CitiesIndex, CountriesIndex],
-              request: request,
-              type: [CitiesIndex::City, CountriesIndex::Country],
-              types: [CitiesIndex::City, CountriesIndex::Country]
+              request: {index: %w[cities countries], body: {sort: ['rating']}, size: 3, scroll: '1m'}
             ),
             hash_including(
               index: [CitiesIndex, CountriesIndex],
               indexes: [CitiesIndex, CountriesIndex],
-              request: {scroll: '1m', scroll_id: an_instance_of(String)},
-              type: [CitiesIndex::City, CountriesIndex::Country],
-              types: [CitiesIndex::City, CountriesIndex::Country]
+              request: {scroll: '1m', scroll_id: an_instance_of(String)}
             )
           ])
         end

data/spec/chewy/search_spec.rb

@@ -37,12 +37,12 @@ describe Chewy::Search do
     end
 
     specify do
-      expect(ProductsIndex.client).to receive(:search).with(hash_including(index: ['products'], type: %w[product]))
+      expect(ProductsIndex.client).to receive(:search).with(hash_including(index: ['products']))
       ProductsIndex.search_string('hello')
     end
 
     specify do
-      expect(ProductsIndex.client).to receive(:search).with(hash_including(index: ['products'], type: %w[product]))
+      expect(ProductsIndex.client).to receive(:search).with(hash_including(index: ['products']))
       product.search_string('hello')
     end
   end

data/spec/chewy/type/import/bulk_request_spec.rb

@@ -32,7 +32,6 @@ describe Chewy::Type::Import::BulkRequest do
     specify do
       expect(Chewy.client).to receive(:bulk).with(
         index: 'places',
-        type: 'city',
         body: [{index: {id: 42, data: {name: 'Name'}}}]
       )
       subject.perform([{index: {id: 42, data: {name: 'Name'}}}])
@@ -44,7 +43,6 @@ describe Chewy::Type::Import::BulkRequest do
       specify do
         expect(Chewy.client).to receive(:bulk).with(
           index: 'places_suffix',
-          type: 'city',
           body: [{index: {id: 42, data: {name: 'Name'}}}]
         )
         subject.perform([{index: {id: 42, data: {name: 'Name'}}}])
@@ -57,7 +55,6 @@ describe Chewy::Type::Import::BulkRequest do
       specify do
         expect(Chewy.client).to receive(:bulk).with(
           index: 'places',
-          type: 'city',
           body: "{\"index\":{\"id\":42}}\n{\"name\":\"#{'Name' * 10}\"}\n{\"index\":{\"id\":43}}\n{\"name\":\"#{'Shame' * 10}\"}\n"
         )
         subject.perform([
@@ -69,17 +66,14 @@ describe Chewy::Type::Import::BulkRequest do
       specify do
         expect(Chewy.client).to receive(:bulk).with(
           index: 'places',
-          type: 'city',
           body: "{\"index\":{\"id\":42}}\n{\"name\":\"#{'Name' * 30}\"}\n"
         )
         expect(Chewy.client).to receive(:bulk).with(
           index: 'places',
-          type: 'city',
           body: "{\"index\":{\"id\":43}}\n{\"name\":\"#{'Shame' * 100}\"}\n"
         )
         expect(Chewy.client).to receive(:bulk).with(
           index: 'places',
-          type: 'city',
           body: "{\"index\":{\"id\":44}}\n{\"name\":\"#{'Blame' * 30}\"}\n"
         )
         subject.perform([