chewy 0.8.4 → 5.1.0

data/spec/chewy/rspec/update_index_spec.rb

@@ -1,90 +1,171 @@
 require 'spec_helper'
 
 describe :update_index do
-  before { Chewy.massacre }
-
   before do
     stub_index(:dummies) do
-      define_type :dummy do
-        root value: ->(o){{}}
-      end
+      define_type :dummy
+      define_type :dummy2
     end
   end
 
-  specify { expect {  }.not_to update_index(DummiesIndex::Dummy) }
+  before do
+    Chewy.massacre
+    DummiesIndex.create!
+  end
+
+  specify { expect {}.not_to update_index(DummiesIndex::Dummy) }
   specify { expect { DummiesIndex::Dummy.bulk body: [] }.not_to update_index(DummiesIndex::Dummy) }
 
-  specify { expect { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42}}] }.not_to update_index(DummiesIndex::Dummy) }
-    .to fail_with(/Expected index .* not to be updated, but it was with/) }
+  specify do
+    expect { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42}}] }.not_to update_index(DummiesIndex::Dummy) }
+      .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::Dummy2.bulk body: [{index: {_id: 43, data: {}}}]
+    end.to update_index(DummiesIndex::Dummy).and_reindex(41, 42).only
+  end
 
   context do
     let(:expectation) do
-      expect { expect {
-        DummiesIndex::Dummy.bulk body: [{index: {_id: 42}}, {index: {_id: 41}}, {index: {_id: 42}}]
-      }.not_to update_index(DummiesIndex::Dummy) }
+      expect do
+        expect do
+          DummiesIndex::Dummy.bulk body: [{index: {_id: 42}}, {index: {_id: 41}}, {index: {_id: 42}}]
+        end.not_to update_index(DummiesIndex::Dummy)
+      end
     end
 
     specify { expectation.to fail_matching 'document id `42` (2 times)' }
     specify { expectation.to fail_matching 'document id `41` (1 times)' }
   end
 
+  context 'compound matchers' do
+    specify do
+      expect do
+        DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
+        DummiesIndex::Dummy2.bulk body: [{index: {_id: 43, data: {}}}]
+      end.to update_index(DummiesIndex::Dummy).and_reindex(41, 42).only
+        .and update_index(DummiesIndex::Dummy2).and_reindex(43).only
+    end
+
+    context do
+      let(:expectation) do
+        expect do
+          expect do
+            DummiesIndex::Dummy2.bulk body: [{index: {_id: 43, data: {}}}]
+          end.to update_index(DummiesIndex::Dummy).and_reindex(41, 42).only
+            .and update_index(DummiesIndex::Dummy2).and_reindex(43).only
+        end
+      end
+
+      specify { expectation.to fail_matching 'Expected index `DummiesIndex::Dummy` to be updated' }
+    end
+  end
+
   context '#only' do
-    specify { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}] }
-      .to update_index(DummiesIndex::Dummy).and_reindex(41, 42).only }
-    specify { expect { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}] }
-      .to update_index(DummiesIndex::Dummy).and_reindex(41).only }
-        .to fail_matching 'to update documents ["41"] only, but ["42"] was updated also' }
-    specify { expect { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}] }
-      .to update_index(DummiesIndex::Dummy).and_reindex(41, times: 2).only }
-        .to fail_matching 'to update documents ["41"] only, but ["42"] was updated also' }
-
-    specify { expect { DummiesIndex::Dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 41}}] }
-      .to update_index(DummiesIndex::Dummy).and_delete(41, 42).only }
-    specify { expect { expect { DummiesIndex::Dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 41}}] }
-      .to update_index(DummiesIndex::Dummy).and_delete(41).only }
-        .to fail_matching 'to delete documents ["41"] only, but ["42"] was deleted also' }
-    specify { expect { expect { DummiesIndex::Dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 41}}] }
-      .to update_index(DummiesIndex::Dummy).and_delete(41, times: 2).only }
-        .to fail_matching 'to delete documents ["41"] only, but ["42"] was deleted also' }
-
-    specify { expect { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {delete: {_id: 41}}] }
-      .to update_index(DummiesIndex::Dummy).and_reindex(42).only }
-        .to fail_matching 'to update documents ["42"] only, but ["41"] was deleted also' }
-    specify { expect { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}, index: {_id: 43, data: {}}}, {delete: {_id: 41}}] }
-      .to update_index(DummiesIndex::Dummy).and_reindex(42).only }
-        .to fail_matching 'to update documents ["42"] only, but ["43"] was updated and ["41"] was deleted also' }
-    specify { expect { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {delete: {_id: 41}}] }
-      .to update_index(DummiesIndex::Dummy).and_delete(41).only }
-        .to fail_matching 'to delete documents ["41"] only, but ["42"] was updated also' }
-    specify { expect { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {delete: {_id: 41}, delete: {_id: 43}}] }
-      .to update_index(DummiesIndex::Dummy).and_delete(41).only }
-        .to fail_matching 'to delete documents ["41"] only, but ["42"] was updated and ["43"] was deleted also' }
+    specify do
+      expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}] }
+        .to update_index(DummiesIndex::Dummy).and_reindex(41, 42).only
+    end
+    specify do
+      expect do
+        expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}] }
+          .to update_index(DummiesIndex::Dummy).and_reindex(41).only
+      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: {}}}] }
+          .to update_index(DummiesIndex::Dummy).and_reindex(41, times: 2).only
+      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}}] }
+        .to update_index(DummiesIndex::Dummy).and_delete(41, 42).only
+    end
+    specify do
+      expect do
+        expect { DummiesIndex::Dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 41}}] }
+          .to update_index(DummiesIndex::Dummy).and_delete(41).only
+      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}}] }
+          .to update_index(DummiesIndex::Dummy).and_delete(41, times: 2).only
+      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}}] }
+          .to update_index(DummiesIndex::Dummy).and_reindex(42).only
+      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::Dummy).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}}] }
+          .to update_index(DummiesIndex::Dummy).and_delete(41).only
+      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::Dummy).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::Dummy) }
-    specify { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}] }
-      .to update_index(DummiesIndex::Dummy).and_reindex(42) }
-    specify { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}] }
-      .to update_index(DummiesIndex::Dummy).and_reindex(double(id: 42)) }
-    specify { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}] }
-      .to update_index(DummiesIndex::Dummy).and_reindex(double(id: 42), double(id: 43)) }
-    specify { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}] }
-      .to update_index(DummiesIndex::Dummy).and_reindex([double(id: 42), 43]) }
-
-    specify do
-      expect {
-        expect {
+    specify do
+      expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}] }
+        .to update_index(DummiesIndex::Dummy).and_reindex(42)
+    end
+    specify do
+      expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}] }
+        .to update_index(DummiesIndex::Dummy).and_reindex(double(id: 42))
+    end
+    specify do
+      expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}] }
+        .to update_index(DummiesIndex::Dummy).and_reindex(double(id: 42), double(id: 43))
+    end
+    specify do
+      expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}] }
+        .to update_index(DummiesIndex::Dummy).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: {}}}]
-        }.to update_index(DummiesIndex::Dummy).and_reindex([44, 43])
-      }.to fail_matching 'Expected document with id `44` to be reindexed, but it was not'
+        end.to update_index(DummiesIndex::Dummy).and_reindex([44, 43])
+      end.to fail_matching 'Expected document with id `44` to be reindexed, but it was not'
     end
 
     context do
       let(:expectation) do
-        expect { expect {
-          DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}]
-        }.to update_index(DummiesIndex::Dummy).and_reindex(44, double(id: 47)) }
+        expect do
+          expect do
+            DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}]
+          end.to update_index(DummiesIndex::Dummy).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') }
@@ -92,23 +173,26 @@ describe :update_index do
     end
 
     context ':times' do
-      specify { expect {
-        DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}]
-        DummiesIndex::Dummy.bulk body: [{index: {_id: 43, data: {}}}, {index: {_id: 44, data: {}}}]
-      }.to update_index(DummiesIndex::Dummy).and_reindex(42, 44, times: 1).and_reindex(43, times: 2) }
+      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::Dummy).and_reindex(42, 44, times: 1).and_reindex(43, times: 2) end
 
-      specify { expect {
-        expect {
-          DummiesIndex::Dummy.bulk body: [{index: {_id: 43, data: {a: '1'}}}]
-        }.to update_index(DummiesIndex::Dummy).and_reindex(42, times: 3)
-      }.to fail_matching('Expected document with id `42` to be reindexed, but it was not') }
+      specify do
+        expect do
+          expect do
+            DummiesIndex::Dummy.bulk body: [{index: {_id: 43, data: {a: '1'}}}]
+          end.to update_index(DummiesIndex::Dummy).and_reindex(42, times: 3)
+        end.to fail_matching('Expected document with id `42` to be reindexed, but it was not') end
 
       context do
         let(:expectation) do
-          expect { expect {
-            DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}]
-            DummiesIndex::Dummy.bulk body: [{index: {_id: 43, data: {}}}, {index: {_id: 44, data: {}}}]
-          }.to update_index(DummiesIndex::Dummy).and_reindex(42, times: 3).and_reindex(44, 43, times: 4) }
+          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::Dummy).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' }
@@ -119,51 +203,57 @@ describe :update_index do
     end
 
     context ':with' do
-      specify { expect {
-        DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {a: '1'}}}, {index: {_id: 42, data: {'a' => 2}}}]
-      }.to update_index(DummiesIndex::Dummy).and_reindex(42, with: {a: 2}) }
+      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::Dummy).and_reindex(42, with: {a: 2}) end
 
-      specify { expect {
-        DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {a: '1'}}}, {index: {_id: 42, data: {'b' => 2}}}]
-      }.to update_index(DummiesIndex::Dummy).and_reindex(42, with: {a: '1', b: 2}) }
+      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::Dummy).and_reindex(42, with: {a: '1', b: 2}) end
 
-      specify { expect {
-        expect {
-          DummiesIndex::Dummy.bulk body: [{index: {_id: 43, data: {a: '1'}}}]
-        }.to update_index(DummiesIndex::Dummy).and_reindex(42, with: {a: 1})
-      }.to fail_matching('Expected document with id `42` to be reindexed, but it was not') }
+      specify do
+        expect do
+          expect do
+            DummiesIndex::Dummy.bulk body: [{index: {_id: 43, data: {a: '1'}}}]
+          end.to update_index(DummiesIndex::Dummy).and_reindex(42, with: {a: 1})
+        end.to fail_matching('Expected document with id `42` to be reindexed, but it was not') end
 
       [
-        [{a: ['one', 'two']}, {a: ['one', 'two']}],
-        [{a: ['one', 'two']}, {a: ['two', 'one']}],
-        [{a: ['one', 'one', 'two']}, {a: ['one', 'two', 'one']}],
-        [{a: {b: ['one', 'one', 'two']}}, {a: {b: ['one', 'two', 'one']}}],
+        [{a: %w[one two]}, {a: %w[one two]}],
+        [{a: %w[one two]}, {a: %w[two one]}],
+        [{a: %w[one one two]}, {a: %w[one two one]}],
+        [{a: {b: %w[one one two]}}, {a: {b: %w[one two one]}}],
         [{a: 1, b: 1}, {a: 1}]
       ].each do |(data, with)|
-        specify { expect {
-          DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: data}}]
-        }.to update_index(DummiesIndex::Dummy).and_reindex(42, with: with) }
+        specify do
+          expect do
+            DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: data}}]
+          end.to update_index(DummiesIndex::Dummy).and_reindex(42, with: with) end
       end
 
       [
-        [{a: ['one', 'two']}, {a: ['one', 'one', 'two']}],
-        [{a: ['one', 'one', 'two']}, {a: ['one', 'two']}],
-        [{a: ['one', 'two']}, {a: 1}],
-        [{a: 1}, {a: ['one', 'two']}],
+        [{a: %w[one two]}, {a: %w[one one two]}],
+        [{a: %w[one one two]}, {a: %w[one two]}],
+        [{a: %w[one two]}, {a: 1}],
+        [{a: 1}, {a: %w[one two]}],
         [{a: 1}, {a: 1, b: 1}]
       ].each do |(data, with)|
-        specify { expect {
-          expect {
-            DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: data}}]
-          }.to update_index(DummiesIndex::Dummy).and_reindex(42, with: with)
-        }.to fail_matching('Expected document with id `42` to be reindexed') }
+        specify do
+          expect do
+            expect do
+              DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: data}}]
+            end.to update_index(DummiesIndex::Dummy).and_reindex(42, with: with)
+          end.to fail_matching('Expected document with id `42` to be reindexed') end
       end
 
       context do
         let(:expectation) do
-          expect { expect {
-            DummiesIndex::Dummy.bulk body: [{index: {_id: 43, data: {a: '1'}}}, {index: {_id: 42, data: {'a' => 2}}}]
-          }.to update_index(DummiesIndex::Dummy).and_reindex(43, times: 2, with: {a: 2}) }
+          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::Dummy).and_reindex(43, times: 2, with: {a: 2}) end
         end
 
         specify { expectation.to fail_matching 'Expected document with id `43` to be reindexed' }
@@ -174,19 +264,29 @@ describe :update_index do
   end
 
   context '#and_delete' do
-    specify { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {delete: {_id: 43}}] }
-      .to update_index(DummiesIndex::Dummy).and_reindex(42).and_delete(double(id: 43)) }
-    specify { expect { DummiesIndex::Dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 43}}] }
-      .to update_index(DummiesIndex::Dummy).and_delete(42).and_delete(double(id: 43)) }
-    specify { expect { DummiesIndex::Dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 43}}] }
-      .to update_index(DummiesIndex::Dummy).and_delete(42, double(id: 43)) }
-    specify { expect { DummiesIndex::Dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 43}}] }
-      .to update_index(DummiesIndex::Dummy).and_delete([43, double(id: 42)]) }
+    specify do
+      expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {delete: {_id: 43}}] }
+        .to update_index(DummiesIndex::Dummy).and_reindex(42).and_delete(double(id: 43))
+    end
+    specify do
+      expect { DummiesIndex::Dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 43}}] }
+        .to update_index(DummiesIndex::Dummy).and_delete(42).and_delete(double(id: 43))
+    end
+    specify do
+      expect { DummiesIndex::Dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 43}}] }
+        .to update_index(DummiesIndex::Dummy).and_delete(42, double(id: 43))
+    end
+    specify do
+      expect { DummiesIndex::Dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 43}}] }
+        .to update_index(DummiesIndex::Dummy).and_delete([43, double(id: 42)])
+    end
 
     context do
       let(:expectation) do
-        expect { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {delete: {_id: 43}}] }
-          .to update_index(DummiesIndex::Dummy).and_reindex(43).and_delete(double(id: 42)) }
+        expect do
+          expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {delete: {_id: 43}}] }
+            .to update_index(DummiesIndex::Dummy).and_reindex(43).and_delete(double(id: 42))
+        end
       end
 
       specify { expectation.to fail_matching 'Expected document with id `43` to be reindexed, but it was not' }
@@ -195,8 +295,10 @@ describe :update_index do
 
     context do
       let(:expectation) do
-        expect { expect { DummiesIndex::Dummy.bulk body: [{delete: {_id: 42, data: {}}}, {delete: {_id: 42}}] }
-          .to update_index(DummiesIndex::Dummy).and_delete(44, times: 2).and_delete(double(id: 42), times: 3) }
+        expect do
+          expect { DummiesIndex::Dummy.bulk body: [{delete: {_id: 42, data: {}}}, {delete: {_id: 42}}] }
+            .to update_index(DummiesIndex::Dummy).and_delete(44, times: 2).and_delete(double(id: 42), times: 3)
+        end
       end
 
       specify { expectation.to fail_matching 'Expected document with id `44` to be deleted, but it was not' }

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 >= '1.0' }
-    specify { expect(described_class.version).to be < '2.2' }
+    specify { expect(described_class.version).to be >= '2.4' }
+    specify { expect(described_class.version).to be < '6.0' }
   end
 end

data/spec/chewy/search/loader_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+describe Chewy::Search::Loader do
+  before { Chewy.massacre }
+
+  before do
+    stub_model(:city)
+    stub_model(:country)
+
+    stub_index(:cities) do
+      define_type City do
+        field :name
+        field :rating, type: 'integer'
+      end
+    end
+
+    stub_index(:countries) do
+      define_type Country do
+        field :name
+        field :rating, type: 'integer'
+      end
+    end
+  end
+
+  before do
+    CitiesIndex.import!(cities: cities)
+    CountriesIndex.import!(countries: countries)
+  end
+
+  let(:cities) { Array.new(2) { |i| City.create!(rating: i, name: "city #{i}") } }
+  let(:countries) { Array.new(2) { |i| Country.create!(rating: i + 2, name: "country #{i}") } }
+
+  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) }
+
+    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) }
+
+    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) }
+    end
+  end
+
+  describe '#load' do
+    let(:hits) { Chewy::Search::Request.new(CitiesIndex, CountriesIndex).order(:rating).hits }
+
+    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') }} }
+        specify { expect(subject.load(hits)).to eq([nil, nil, nil, countries.last]) }
+      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) }}} }
+        specify { expect(subject.load(hits)).to eq([*cities, nil, countries.last]) }
+      end
+    end
+
+    context 'objects' do
+      before do
+        stub_index(:cities) do
+          define_type :city do
+            field :name
+            field :rating, type: 'integer'
+          end
+        end
+
+        stub_index(:countries) do
+          define_type :country do
+            field :name
+            field :rating, type: 'integer'
+          end
+        end
+      end
+
+      specify { expect(subject.load(hits).map(&:class).uniq).to eq([CitiesIndex::City, CountriesIndex::Country]) }
+      specify { expect(subject.load(hits).map(&:rating)).to eq([*cities, *countries].map(&:rating)) }
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+shared_examples :kaminari do |request_base_class|
+  before { Chewy.massacre }
+
+  before do
+    stub_index(:products) do
+      define_type(:product) do
+        field :name
+        field :age, type: 'integer'
+      end
+    end
+  end
+
+  let(:except_fields) { %w[_score _explanation] }
+  let(:request_class) do
+    Class.new(request_base_class).tap do |k|
+      k.include Chewy::Search::Pagination::Kaminari
+    end
+  end
+  let(:search) { request_class.new(ProductsIndex).order(:age) }
+
+  specify { expect(search.total_pages).to eq(0) }
+
+  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) }
+
+    describe '#per, #page' do
+      specify { expect(search.map { |e| e.attributes.except(*except_fields) }).to match_array(data) }
+      specify { expect(search.page(1).map { |e| e.attributes.except(*except_fields) }).to eq(data[0..2]) }
+      specify { expect(search.page(2).map { |e| e.attributes.except(*except_fields) }).to eq(data[3..5]) }
+      specify { expect(search.page(2).per(4).map { |e| e.attributes.except(*except_fields) }).to eq(data[4..7]) }
+      specify { expect(search.per(2).page(3).map { |e| e.attributes.except(*except_fields) }).to eq(data[4..5]) }
+      specify { expect(search.per(5).page.map { |e| e.attributes.except(*except_fields) }).to eq(data[0..4]) }
+      specify { expect(search.page.per(4).map { |e| e.attributes.except(*except_fields) }).to eq(data[0..3]) }
+    end
+
+    describe '#total_pages' do
+      specify { expect(search.total_pages).to eq(4) }
+      specify { expect(search.per(5).page(2).total_pages).to eq(2) }
+      specify { expect(search.per(2).page(3).total_pages).to eq(5) }
+    end
+
+    describe '#total_count' do
+      specify { expect(search.per(4).page(1).total_count).to eq(10) }
+      specify { expect(search.query(range: {age: {gt: 20}}).limit(3).total_count).to eq(8) }
+    end
+
+    describe '#load' do
+      specify { expect(search.per(2).page(1).load.first.age).to eq(10) }
+      specify { expect(search.per(2).page(3).load.first.age).to eq(50) }
+      specify { expect(search.per(2).page(3).load.page(2).load.first.age).to eq(30) }
+
+      specify { expect(search.per(4).page(1).load.total_count).to eq(10) }
+      specify { expect(search.per(2).page(3).load.total_pages).to eq(5) }
+    end
+
+    describe '#limit_value' do
+      specify { expect(search.limit_value).to eq(3) }
+      specify { expect(search.per(15).limit_value).to eq(15) }
+    end
+
+    describe '#offset_value' do
+      specify { expect(search.offset_value).to eq(0) }
+      specify { expect(search.page(3).offset_value).to eq(6) }
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require 'chewy/search/pagination/kaminari_examples'
+
+describe Chewy::Search::Pagination::Kaminari do
+  it_behaves_like :kaminari, Chewy::Search::Request 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) }
+
+      specify { expect(search.objects.class).to eq(Kaminari::PaginatableArray) }
+      specify { expect(search.objects.total_count).to eq(12) }
+      specify { expect(search.objects.limit_value).to eq(17) }
+      specify { expect(search.objects.offset_value).to eq(0) }
+      specify { expect(search.per(2).page(3).objects.class).to eq(Kaminari::PaginatableArray) }
+      specify { expect(search.per(2).page(3).objects.total_count).to eq(12) }
+      specify { expect(search.per(2).page(3).objects.limit_value).to eq(2) }
+      specify { expect(search.per(2).page(3).objects.offset_value).to eq(4) }
+    end
+  end
+end