chewy 0.10.0 → 6.0.0

data/spec/chewy/rspec/update_index_spec.rb

@@ -4,7 +4,9 @@ describe :update_index do
   before do
     stub_index(:dummies) do
       define_type :dummy
-      define_type :dummy2
+    end
+    stub_index(:dummies2) do
+      define_type :dummy
     end
   end
 
@@ -13,19 +15,18 @@ describe :update_index do
     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 {}.not_to update_index(DummiesIndex) }
+  specify { expect { DummiesIndex::Dummy.bulk body: [] }.not_to update_index(DummiesIndex) }
 
   specify do
-    expect { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42}}] }.not_to update_index(DummiesIndex::Dummy) }
+    expect { expect { DummiesIndex::Dummy.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::Dummy2.bulk body: [{index: {_id: 43, data: {}}}]
-    end.to update_index(DummiesIndex::Dummy).and_reindex(41, 42).only
+    end.to update_index(DummiesIndex).and_reindex(41, 42).only
   end
 
   context do
@@ -33,7 +34,7 @@ describe :update_index do
       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.not_to update_index(DummiesIndex)
       end
     end
 
@@ -45,60 +46,60 @@ describe :update_index 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
+        Dummies2Index::Dummy.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
 
     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
+            Dummies2Index::Dummy.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
       end
 
-      specify { expectation.to fail_matching 'Expected index `DummiesIndex::Dummy` to be updated' }
+      specify { expectation.to fail_matching 'Expected index `DummiesIndex` to be updated' }
     end
   end
 
   context '#only' do
     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
+        .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: {}}}] }
-          .to update_index(DummiesIndex::Dummy).and_reindex(41).only
+          .to update_index(DummiesIndex).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
+          .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
 
     specify do
       expect { DummiesIndex::Dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 41}}] }
-        .to update_index(DummiesIndex::Dummy).and_delete(41, 42).only
+        .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}}] }
-          .to update_index(DummiesIndex::Dummy).and_delete(41).only
+          .to update_index(DummiesIndex).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
+          .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
@@ -106,57 +107,57 @@ describe :update_index do
     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
+          .to update_index(DummiesIndex).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
+          .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}}] }
-          .to update_index(DummiesIndex::Dummy).and_delete(41).only
+          .to update_index(DummiesIndex).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
+          .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::Dummy) }
+    specify { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42}}] }.to update_index(DummiesIndex) }
     specify do
       expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}] }
-        .to update_index(DummiesIndex::Dummy).and_reindex(42)
+        .to update_index(DummiesIndex).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))
+        .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: {}}}] }
-        .to update_index(DummiesIndex::Dummy).and_reindex(double(id: 42), double(id: 43))
+        .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: {}}}] }
-        .to update_index(DummiesIndex::Dummy).and_reindex([double(id: 42), 43])
+        .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: {}}}]
-        end.to update_index(DummiesIndex::Dummy).and_reindex([44, 43])
+        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,7 +166,7 @@ describe :update_index do
         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.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') }
@@ -177,13 +178,13 @@ describe :update_index 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
+        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'}}}]
-          end.to update_index(DummiesIndex::Dummy).and_reindex(42, times: 3)
+          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
 
       context do
@@ -192,7 +193,7 @@ describe :update_index 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.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,18 +207,18 @@ describe :update_index 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::Dummy).and_reindex(42, with: {a: 2}) end
+        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::Dummy).and_reindex(42, with: {a: '1', b: 2}) end
+        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'}}}]
-          end.to update_index(DummiesIndex::Dummy).and_reindex(42, with: {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
 
       [
@@ -230,7 +231,7 @@ describe :update_index do
         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.to update_index(DummiesIndex).and_reindex(42, with: with) end
       end
 
       [
@@ -244,7 +245,7 @@ describe :update_index 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 update_index(DummiesIndex).and_reindex(42, with: with)
           end.to fail_matching('Expected document with id `42` to be reindexed') end
       end
 
@@ -253,7 +254,7 @@ describe :update_index 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::Dummy).and_reindex(43, times: 2, with: {a: 2}) end
+            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 +267,26 @@ describe :update_index do
   context '#and_delete' do
     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))
+        .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}}] }
-        .to update_index(DummiesIndex::Dummy).and_delete(42).and_delete(double(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}}] }
-        .to update_index(DummiesIndex::Dummy).and_delete(42, double(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}}] }
-        .to update_index(DummiesIndex::Dummy).and_delete([43, double(id: 42)])
+        .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}}] }
-            .to update_index(DummiesIndex::Dummy).and_reindex(43).and_delete(double(id: 42))
+            .to update_index(DummiesIndex).and_reindex(43).and_delete(double(id: 42))
         end
       end
 
@@ -297,7 +298,7 @@ describe :update_index do
       let(:expectation) do
         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)
+            .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 >= '2.4' }
-    specify { expect(described_class.version).to be < '6.0' }
+    specify { expect(described_class.version).to be >= '5.6' }
+    specify { expect(described_class.version).to be < '7.0' }
   end
 end

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

@@ -3,13 +3,17 @@ 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(10) { |i| {id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next}.stringify_keys! } }
+      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: 3) }
+      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(10) }
+      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

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

@@ -3,13 +3,19 @@ require 'chewy/search/pagination/will_paginate_examples'
 describe Chewy::Search::Pagination::WillPaginate do
   it_behaves_like :will_paginate, Chewy::Search::Request do
     describe '#objects' do
-      let(:data) { Array.new(10) { |i| {id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next}.stringify_keys! } }
+      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(::WillPaginate).to receive_messages(per_page: 3) }
+      before { allow(::WillPaginate).to receive_messages(per_page: 17) }
 
+      # specify { expect(search.current_page).to eq(1) }
+      # specify { expect(search.per_page).to eq(0) }
+      specify { expect(search.objects.class).to eq(WillPaginate::Collection) }
+      specify { expect(search.objects.total_entries).to eq(12) }
+      specify { expect(search.objects.per_page).to eq(17) }
+      specify { expect(search.objects.current_page).to eq(1) }
       specify { expect(search.paginate(per_page: 2, page: 3).objects.class).to eq(WillPaginate::Collection) }
-      specify { expect(search.paginate(per_page: 2, page: 3).objects.total_entries).to eq(10) }
+      specify { expect(search.paginate(per_page: 2, page: 3).objects.total_entries).to eq(12) }
       specify { expect(search.paginate(per_page: 2, page: 3).objects.per_page).to eq(2) }
       specify { expect(search.paginate(per_page: 2, page: 3).objects.current_page).to eq(3) }
     end

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

@@ -0,0 +1,190 @@
+require 'spec_helper'
+
+describe Chewy::Search::Parameters::Indices do
+  before do
+    stub_index(:first) do
+      define_type :one
+    end
+
+    stub_index(:second) do
+      define_type :three
+    end
+  end
+
+  subject { described_class.new(indices: FirstIndex, types: SecondIndex::Three) }
+
+  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]) }
+  end
+
+  describe '#replace!' do
+    specify do
+      expect { subject.replace!(nil) }
+        .to change { subject.value }
+        .from(indices: [FirstIndex], types: [SecondIndex::Three])
+        .to(indices: [], types: [])
+    end
+
+    specify do
+      expect { subject.replace!(indices: SecondIndex, types: FirstIndex::One) }
+        .to change { subject.value }
+        .from(indices: [FirstIndex], types: [SecondIndex::Three])
+        .to(indices: [SecondIndex], types: [FirstIndex::One])
+    end
+  end
+
+  describe '#update!' do
+    specify do
+      expect { subject.update!(nil) }
+        .not_to change { subject.value }
+    end
+
+    specify do
+      expect { subject.update!(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])
+    end
+  end
+
+  describe '#merge!' do
+    specify do
+      expect { subject.merge!(described_class.new) }
+        .not_to change { subject.value }
+    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])
+    end
+  end
+
+  describe '#render' do
+    specify { expect(described_class.new.render).to eq({}) }
+    specify do
+      expect(described_class.new(
+        indices: FirstIndex
+      ).render).to eq(index: %w[first], type: %w[one])
+    end
+    specify do
+      expect(described_class.new(
+        indices: :whatever
+      ).render).to eq(index: %w[whatever])
+    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])
+    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]))
+        .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))
+    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
+      )
+    end
+  end
+end