chewy 6.0.0 → 7.6.0

data/spec/chewy/rspec/update_index_spec.rb

@@ -3,10 +3,8 @@ require 'spec_helper'
 describe :update_index do
   before do
     stub_index(:dummies) do
-      define_type :dummy
     end
     stub_index(:dummies2) do
-      define_type :dummy
     end
   end
 
@@ -16,16 +14,16 @@ describe :update_index do
   end
 
   specify { expect {}.not_to update_index(DummiesIndex) }
-  specify { expect { DummiesIndex::Dummy.bulk body: [] }.not_to update_index(DummiesIndex) }
+  specify { expect { DummiesIndex.bulk body: [] }.not_to update_index(DummiesIndex) }
 
   specify do
-    expect { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42}}] }.not_to update_index(DummiesIndex) }
+    expect { expect { DummiesIndex.bulk body: [{index: {_id: 42}}] }.not_to update_index(DummiesIndex) }
       .to fail_with(/Expected index .* not to be updated, but it was with/)
   end
 
   specify do
     expect do
-      DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
+      DummiesIndex.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
     end.to update_index(DummiesIndex).and_reindex(41, 42).only
   end
 
@@ -33,7 +31,7 @@ describe :update_index do
     let(:expectation) do
       expect do
         expect do
-          DummiesIndex::Dummy.bulk body: [{index: {_id: 42}}, {index: {_id: 41}}, {index: {_id: 42}}]
+          DummiesIndex.bulk body: [{index: {_id: 42}}, {index: {_id: 41}}, {index: {_id: 42}}]
         end.not_to update_index(DummiesIndex)
       end
     end
@@ -45,8 +43,8 @@ describe :update_index do
   context 'compound matchers' do
     specify do
       expect do
-        DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
-        Dummies2Index::Dummy.bulk body: [{index: {_id: 43, data: {}}}]
+        DummiesIndex.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
+        Dummies2Index.bulk body: [{index: {_id: 43, data: {}}}]
       end.to update_index(DummiesIndex).and_reindex(41, 42).only
         .and update_index(Dummies2Index).and_reindex(43).only
     end
@@ -55,7 +53,7 @@ describe :update_index do
       let(:expectation) do
         expect do
           expect do
-            Dummies2Index::Dummy.bulk body: [{index: {_id: 43, data: {}}}]
+            Dummies2Index.bulk body: [{index: {_id: 43, data: {}}}]
           end.to update_index(DummiesIndex).and_reindex(41, 42).only
             .and update_index(Dummies2Index).and_reindex(43).only
         end
@@ -67,96 +65,91 @@ describe :update_index do
 
   context '#only' do
     specify do
-      expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}] }
+      expect { DummiesIndex.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}] }
         .to update_index(DummiesIndex).and_reindex(41, 42).only
     end
     specify do
       expect do
-        expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}] }
+        expect { DummiesIndex.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}] }
           .to update_index(DummiesIndex).and_reindex(41).only
-      end
-        .to fail_matching 'to update documents ["41"] only, but ["42"] was updated also'
+      end.to fail_matching 'to update documents ["41"] only, but ["42"] was updated also'
     end
     specify do
       expect do
-        expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}] }
+        expect { DummiesIndex.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}] }
           .to update_index(DummiesIndex).and_reindex(41, times: 2).only
-      end
-        .to fail_matching 'to update documents ["41"] only, but ["42"] was updated also'
+      end.to fail_matching 'to update documents ["41"] only, but ["42"] was updated also'
     end
 
     specify do
-      expect { DummiesIndex::Dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 41}}] }
+      expect { DummiesIndex.bulk body: [{delete: {_id: 42}}, {delete: {_id: 41}}] }
         .to update_index(DummiesIndex).and_delete(41, 42).only
     end
     specify do
       expect do
-        expect { DummiesIndex::Dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 41}}] }
+        expect { DummiesIndex.bulk body: [{delete: {_id: 42}}, {delete: {_id: 41}}] }
           .to update_index(DummiesIndex).and_delete(41).only
-      end
-        .to fail_matching 'to delete documents ["41"] only, but ["42"] was deleted also'
+      end.to fail_matching 'to delete documents ["41"] only, but ["42"] was deleted also'
     end
     specify do
       expect do
-        expect { DummiesIndex::Dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 41}}] }
+        expect { DummiesIndex.bulk body: [{delete: {_id: 42}}, {delete: {_id: 41}}] }
           .to update_index(DummiesIndex).and_delete(41, times: 2).only
-      end
-        .to fail_matching 'to delete documents ["41"] only, but ["42"] was deleted also'
+      end.to fail_matching 'to delete documents ["41"] only, but ["42"] was deleted also'
     end
 
     specify do
       expect do
-        expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {delete: {_id: 41}}] }
+        expect { DummiesIndex.bulk body: [{index: {_id: 42, data: {}}}, {delete: {_id: 41}}] }
           .to update_index(DummiesIndex).and_reindex(42).only
-      end
-        .to fail_matching 'to update documents ["42"] only, but ["41"] was deleted also'
+      end.to fail_matching 'to update documents ["42"] only, but ["41"] was deleted also'
     end
     specify do
       expect do
-        expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}, {delete: {_id: 41}}] }
-          .to update_index(DummiesIndex).and_reindex(42).only
-      end
-        .to fail_matching 'to update documents ["42"] only, but ["43"] was updated and ["41"] was deleted also'
+        expect do
+          DummiesIndex.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}},
+                                   {delete: {_id: 41}}]
+        end.to update_index(DummiesIndex).and_reindex(42).only
+      end.to fail_matching 'to update documents ["42"] only, but ["43"] was updated and ["41"] was deleted also'
     end
     specify do
       expect do
-        expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {delete: {_id: 41}}] }
+        expect { DummiesIndex.bulk body: [{index: {_id: 42, data: {}}}, {delete: {_id: 41}}] }
           .to update_index(DummiesIndex).and_delete(41).only
-      end
-        .to fail_matching 'to delete documents ["41"] only, but ["42"] was updated also'
+      end.to fail_matching 'to delete documents ["41"] only, but ["42"] was updated also'
     end
     specify do
       expect do
-        expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {delete: {_id: 41}}, {delete: {_id: 43}}] }
-          .to update_index(DummiesIndex).and_delete(41).only
-      end
-        .to fail_matching 'to delete documents ["41"] only, but ["42"] was updated and ["43"] was deleted also'
+        expect do
+          DummiesIndex.bulk body: [{index: {_id: 42, data: {}}}, {delete: {_id: 41}}, {delete: {_id: 43}}]
+        end.to update_index(DummiesIndex).and_delete(41).only
+      end.to fail_matching 'to delete documents ["41"] only, but ["42"] was updated and ["43"] was deleted also'
     end
   end
 
   context '#and_reindex' do
-    specify { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42}}] }.to update_index(DummiesIndex) }
+    specify { expect { DummiesIndex.bulk body: [{index: {_id: 42}}] }.to update_index(DummiesIndex) }
     specify do
-      expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}] }
+      expect { DummiesIndex.bulk body: [{index: {_id: 42, data: {}}}] }
         .to update_index(DummiesIndex).and_reindex(42)
     end
     specify do
-      expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}] }
+      expect { DummiesIndex.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}] }
         .to update_index(DummiesIndex).and_reindex(double(id: 42))
     end
     specify do
-      expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}] }
+      expect { DummiesIndex.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}] }
         .to update_index(DummiesIndex).and_reindex(double(id: 42), double(id: 43))
     end
     specify do
-      expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}] }
+      expect { DummiesIndex.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}] }
         .to update_index(DummiesIndex).and_reindex([double(id: 42), 43])
     end
 
     specify do
       expect do
         expect do
-          DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}]
+          DummiesIndex.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}]
         end.to update_index(DummiesIndex).and_reindex([44, 43])
       end.to fail_matching 'Expected document with id `44` to be reindexed, but it was not'
     end
@@ -165,8 +158,9 @@ describe :update_index do
       let(:expectation) do
         expect do
           expect do
-            DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}]
-          end.to update_index(DummiesIndex).and_reindex(44, double(id: 47)) end
+            DummiesIndex.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}]
+          end.to update_index(DummiesIndex).and_reindex(44, double(id: 47))
+        end
       end
 
       specify { expectation.to fail_matching('Expected document with id `44` to be reindexed, but it was not') }
@@ -176,24 +170,27 @@ describe :update_index do
     context ':times' do
       specify do
         expect do
-          DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}]
-          DummiesIndex::Dummy.bulk body: [{index: {_id: 43, data: {}}}, {index: {_id: 44, data: {}}}]
-        end.to update_index(DummiesIndex).and_reindex(42, 44, times: 1).and_reindex(43, times: 2) end
+          DummiesIndex.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}]
+          DummiesIndex.bulk body: [{index: {_id: 43, data: {}}}, {index: {_id: 44, data: {}}}]
+        end.to update_index(DummiesIndex).and_reindex(42, 44, times: 1).and_reindex(43, times: 2)
+      end
 
       specify do
         expect do
           expect do
-            DummiesIndex::Dummy.bulk body: [{index: {_id: 43, data: {a: '1'}}}]
+            DummiesIndex.bulk body: [{index: {_id: 43, data: {a: '1'}}}]
           end.to update_index(DummiesIndex).and_reindex(42, times: 3)
-        end.to fail_matching('Expected document with id `42` to be reindexed, but it was not') end
+        end.to fail_matching('Expected document with id `42` to be reindexed, but it was not')
+      end
 
       context do
         let(:expectation) do
           expect do
             expect do
-              DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}]
-              DummiesIndex::Dummy.bulk body: [{index: {_id: 43, data: {}}}, {index: {_id: 44, data: {}}}]
-            end.to update_index(DummiesIndex).and_reindex(42, times: 3).and_reindex(44, 43, times: 4) end
+              DummiesIndex.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}]
+              DummiesIndex.bulk body: [{index: {_id: 43, data: {}}}, {index: {_id: 44, data: {}}}]
+            end.to update_index(DummiesIndex).and_reindex(42, times: 3).and_reindex(44, 43, times: 4)
+          end
         end
 
         specify { expectation.to fail_matching 'Expected document with id `44` to be reindexed' }
@@ -206,20 +203,23 @@ describe :update_index do
     context ':with' do
       specify do
         expect do
-          DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {a: '1'}}}, {index: {_id: 42, data: {'a' => 2}}}]
-        end.to update_index(DummiesIndex).and_reindex(42, with: {a: 2}) end
+          DummiesIndex.bulk body: [{index: {_id: 42, data: {a: '1'}}}, {index: {_id: 42, data: {'a' => 2}}}]
+        end.to update_index(DummiesIndex).and_reindex(42, with: {a: 2})
+      end
 
       specify do
         expect do
-          DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {a: '1'}}}, {index: {_id: 42, data: {'b' => 2}}}]
-        end.to update_index(DummiesIndex).and_reindex(42, with: {a: '1', b: 2}) end
+          DummiesIndex.bulk body: [{index: {_id: 42, data: {a: '1'}}}, {index: {_id: 42, data: {'b' => 2}}}]
+        end.to update_index(DummiesIndex).and_reindex(42, with: {a: '1', b: 2})
+      end
 
       specify do
         expect do
           expect do
-            DummiesIndex::Dummy.bulk body: [{index: {_id: 43, data: {a: '1'}}}]
+            DummiesIndex.bulk body: [{index: {_id: 43, data: {a: '1'}}}]
           end.to update_index(DummiesIndex).and_reindex(42, with: {a: 1})
-        end.to fail_matching('Expected document with id `42` to be reindexed, but it was not') end
+        end.to fail_matching('Expected document with id `42` to be reindexed, but it was not')
+      end
 
       [
         [{a: %w[one two]}, {a: %w[one two]}],
@@ -230,8 +230,9 @@ describe :update_index do
       ].each do |(data, with)|
         specify do
           expect do
-            DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: data}}]
-          end.to update_index(DummiesIndex).and_reindex(42, with: with) end
+            DummiesIndex.bulk body: [{index: {_id: 42, data: data}}]
+          end.to update_index(DummiesIndex).and_reindex(42, with: with)
+        end
       end
 
       [
@@ -244,17 +245,19 @@ describe :update_index do
         specify do
           expect do
             expect do
-              DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: data}}]
+              DummiesIndex.bulk body: [{index: {_id: 42, data: data}}]
             end.to update_index(DummiesIndex).and_reindex(42, with: with)
-          end.to fail_matching('Expected document with id `42` to be reindexed') end
+          end.to fail_matching('Expected document with id `42` to be reindexed')
+        end
       end
 
       context do
         let(:expectation) do
           expect do
             expect do
-              DummiesIndex::Dummy.bulk body: [{index: {_id: 43, data: {a: '1'}}}, {index: {_id: 42, data: {'a' => 2}}}]
-            end.to update_index(DummiesIndex).and_reindex(43, times: 2, with: {a: 2}) end
+              DummiesIndex.bulk body: [{index: {_id: 43, data: {a: '1'}}}, {index: {_id: 42, data: {'a' => 2}}}]
+            end.to update_index(DummiesIndex).and_reindex(43, times: 2, with: {a: 2})
+          end
         end
 
         specify { expectation.to fail_matching 'Expected document with id `43` to be reindexed' }
@@ -266,26 +269,26 @@ describe :update_index do
 
   context '#and_delete' do
     specify do
-      expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {delete: {_id: 43}}] }
+      expect { DummiesIndex.bulk body: [{index: {_id: 42, data: {}}}, {delete: {_id: 43}}] }
         .to update_index(DummiesIndex).and_reindex(42).and_delete(double(id: 43))
     end
     specify do
-      expect { DummiesIndex::Dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 43}}] }
+      expect { DummiesIndex.bulk body: [{delete: {_id: 42}}, {delete: {_id: 43}}] }
         .to update_index(DummiesIndex).and_delete(42).and_delete(double(id: 43))
     end
     specify do
-      expect { DummiesIndex::Dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 43}}] }
+      expect { DummiesIndex.bulk body: [{delete: {_id: 42}}, {delete: {_id: 43}}] }
         .to update_index(DummiesIndex).and_delete(42, double(id: 43))
     end
     specify do
-      expect { DummiesIndex::Dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 43}}] }
+      expect { DummiesIndex.bulk body: [{delete: {_id: 42}}, {delete: {_id: 43}}] }
         .to update_index(DummiesIndex).and_delete([43, double(id: 42)])
     end
 
     context do
       let(:expectation) do
         expect do
-          expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {delete: {_id: 43}}] }
+          expect { DummiesIndex.bulk body: [{index: {_id: 42, data: {}}}, {delete: {_id: 43}}] }
             .to update_index(DummiesIndex).and_reindex(43).and_delete(double(id: 42))
         end
       end
@@ -297,7 +300,7 @@ describe :update_index do
     context do
       let(:expectation) do
         expect do
-          expect { DummiesIndex::Dummy.bulk body: [{delete: {_id: 42, data: {}}}, {delete: {_id: 42}}] }
+          expect { DummiesIndex.bulk body: [{delete: {_id: 42, data: {}}}, {delete: {_id: 42}}] }
             .to update_index(DummiesIndex).and_delete(44, times: 2).and_delete(double(id: 42), times: 3)
         end
       end

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 >= '5.6' }
-    specify { expect(described_class.version).to be < '7.0' }
+    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

@@ -8,17 +8,15 @@ describe Chewy::Search::Loader do
     stub_model(:country)
 
     stub_index(:cities) do
-      define_type City do
-        field :name
-        field :rating, type: 'integer'
-      end
+      index_scope City
+      field :name
+      field :rating, type: 'integer'
     end
 
     stub_index(:countries) do
-      define_type Country do
-        field :name
-        field :rating, type: 'integer'
-      end
+      index_scope Country
+      field :name
+      field :rating, type: 'integer'
     end
   end
 
@@ -33,19 +31,18 @@ describe Chewy::Search::Loader do
   let(:options) { {} }
   subject { described_class.new(indexes: [CitiesIndex, CountriesIndex], **options) }
 
-  describe '#derive_type' do
-    specify { expect(subject.derive_type('cities', 'city')).to eq(CitiesIndex::City) }
-    specify { expect(subject.derive_type('cities_suffix', 'city')).to eq(CitiesIndex::City) }
+  describe '#derive_index' do
+    specify { expect(subject.derive_index('cities')).to eq(CitiesIndex) }
+    specify { expect(subject.derive_index('cities_suffix')).to eq(CitiesIndex) }
 
-    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) }
+    specify { expect { subject.derive_index('whatever') }.to raise_error(Chewy::UndefinedIndex) }
+    specify { expect { subject.derive_index('citiessuffix') }.to raise_error(Chewy::UndefinedIndex) }
 
     context do
       before { CitiesIndex.index_name :boro_goves }
 
-      specify { expect(subject.derive_type('boro_goves', 'city')).to eq(CitiesIndex::City) }
-      specify { expect(subject.derive_type('boro_goves_suffix', 'city')).to eq(CitiesIndex::City) }
+      specify { expect(subject.derive_index('boro_goves')).to eq(CitiesIndex) }
+      specify { expect(subject.derive_index('boro_goves_suffix')).to eq(CitiesIndex) }
     end
   end
 
@@ -54,21 +51,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') }} }
@@ -76,19 +58,7 @@ describe Chewy::Search::Loader do
       end
 
       context do
-        let(:options) { {country: {scope: -> { where('rating > 2') }}} }
-        specify { expect(subject.load(hits)).to eq([*cities, nil, countries.last]) }
-      end
-    end
-
-    context 'scopes', :mongoid do
-      context do
-        let(:options) { {scope: -> { where(:rating.gt => 2) }} }
-        specify { expect(subject.load(hits)).to eq([nil, nil, nil, countries.last]) }
-      end
-
-      context do
-        let(:options) { {country: {scope: -> { where(:rating.gt => 2) }}} }
+        let(:options) { {countries: {scope: -> { where('rating > 2') }}} }
         specify { expect(subject.load(hits)).to eq([*cities, nil, countries.last]) }
       end
     end
@@ -96,21 +66,17 @@ describe Chewy::Search::Loader do
     context 'objects' do
       before do
         stub_index(:cities) do
-          define_type :city do
-            field :name
-            field :rating, type: 'integer'
-          end
+          field :name
+          field :rating, type: 'integer'
         end
 
         stub_index(:countries) do
-          define_type :country do
-            field :name
-            field :rating, type: 'integer'
-          end
+          field :name
+          field :rating, type: 'integer'
         end
       end
 
-      specify { expect(subject.load(hits).map(&:class).uniq).to eq([CitiesIndex::City, CountriesIndex::Country]) }
+      specify { expect(subject.load(hits).map(&:class).uniq).to eq([CitiesIndex, CountriesIndex]) }
       specify { expect(subject.load(hits).map(&:rating)).to eq([*cities, *countries].map(&:rating)) }
     end
   end

data/spec/chewy/search/pagination/kaminari_examples.rb

@@ -5,10 +5,8 @@ shared_examples :kaminari do |request_base_class|
 
   before do
     stub_index(:products) do
-      define_type(:product) do
-        field :name
-        field :age, type: 'integer'
-      end
+      field :name
+      field :age, type: 'integer'
     end
   end
 
@@ -25,8 +23,8 @@ shared_examples :kaminari do |request_base_class|
   context do
     let(:data) { Array.new(10) { |i| {id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next}.stringify_keys! } }
 
-    before { ProductsIndex::Product.import!(data.map { |h| double(h) }) }
-    before { allow(::Kaminari.config).to receive_messages(default_per_page: 3) }
+    before { ProductsIndex.import!(data.map { |h| double(h) }) }
+    before { allow(Kaminari.config).to receive_messages(default_per_page: 3) }
 
     describe '#per, #page' do
       specify { expect(search.map { |e| e.attributes.except(*except_fields) }).to match_array(data) }

data/spec/chewy/search/pagination/kaminari_spec.rb

@@ -5,8 +5,8 @@ describe Chewy::Search::Pagination::Kaminari do
     describe '#objects' do
       let(:data) { Array.new(12) { |i| {id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next}.stringify_keys! } }
 
-      before { ProductsIndex::Product.import!(data.map { |h| double(h) }) }
-      before { allow(::Kaminari.config).to receive_messages(default_per_page: 17) }
+      before { ProductsIndex.import!(data.map { |h| double(h) }) }
+      before { allow(Kaminari.config).to receive_messages(default_per_page: 17) }
 
       specify { expect(search.objects.class).to eq(Kaminari::PaginatableArray) }
       specify { expect(search.objects.total_count).to eq(12) }

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

@@ -0,0 +1,5 @@
+require 'chewy/search/parameters/hash_storage_examples'
+
+describe Chewy::Search::Parameters::Collapse do
+  it_behaves_like :hash_storage, :collapse
+end

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

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Chewy::Search::Parameters::IgnoreUnavailable do
+  subject { described_class.new(true) }
+
+  describe '#initialize' do
+    specify { expect(subject.value).to eq(true) }
+    specify { expect(described_class.new.value).to eq(nil) }
+    specify { expect(described_class.new(42).value).to eq(true) }
+    specify { expect(described_class.new(false).value).to eq(false) }
+  end
+
+  describe '#replace!' do
+    specify { expect { subject.replace!(false) }.to change { subject.value }.from(true).to(false) }
+    specify { expect { subject.replace!(nil) }.to change { subject.value }.from(true).to(nil) }
+  end
+
+  describe '#update!' do
+    specify { expect { subject.update!(nil) }.not_to change { subject.value }.from(true) }
+    specify { expect { subject.update!(false) }.to change { subject.value }.from(true).to(false) }
+    specify { expect { subject.update!(true) }.not_to change { subject.value }.from(true) }
+
+    context do
+      subject { described_class.new(false) }
+
+      specify { expect { subject.update!(nil) }.not_to change { subject.value }.from(false) }
+      specify { expect { subject.update!(false) }.not_to change { subject.value }.from(false) }
+      specify { expect { subject.update!(true) }.to change { subject.value }.from(false).to(true) }
+    end
+
+    context do
+      subject { described_class.new }
+
+      specify { expect { subject.update!(nil) }.not_to change { subject.value }.from(nil) }
+      specify { expect { subject.update!(false) }.to change { subject.value }.from(nil).to(false) }
+      specify { expect { subject.update!(true) }.to change { subject.value }.from(nil).to(true) }
+    end
+  end
+
+  describe '#merge!' do
+    specify { expect { subject.merge!(described_class.new) }.not_to change { subject.value }.from(true) }
+    specify { expect { subject.merge!(described_class.new(false)) }.to change { subject.value }.from(true).to(false) }
+    specify { expect { subject.merge!(described_class.new(true)) }.not_to change { subject.value }.from(true) }
+
+    context do
+      subject { described_class.new(false) }
+
+      specify { expect { subject.merge!(described_class.new) }.not_to change { subject.value }.from(false) }
+      specify { expect { subject.merge!(described_class.new(false)) }.not_to change { subject.value }.from(false) }
+      specify { expect { subject.merge!(described_class.new(true)) }.to change { subject.value }.from(false).to(true) }
+    end
+
+    context do
+      subject { described_class.new }
+
+      specify { expect { subject.merge!(described_class.new) }.not_to change { subject.value }.from(nil) }
+      specify { expect { subject.merge!(described_class.new(false)) }.to change { subject.value }.from(nil).to(false) }
+      specify { expect { subject.merge!(described_class.new(true)) }.to change { subject.value }.from(nil).to(true) }
+    end
+  end
+
+  describe '#render' do
+    specify { expect(described_class.new.render).to be_nil }
+    specify { expect(described_class.new(false).render).to eq(ignore_unavailable: false) }
+    specify { expect(subject.render).to eq(ignore_unavailable: true) }
+  end
+end