chewy 8.0.0 → 8.1.0

data/spec/chewy/rspec/build_query_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-describe :build_query do
-  before do
-    stub_model(:city)
-    stub_index(:cities) { index_scope City }
-    CitiesIndex.create
-  end
-
-  let(:expected_query) do
-    {
-      index: ['cities'],
-      body: {
-        query: {
-          match: {name: 'name'}
-        }
-      }
-    }
-  end
-  let(:dummy_query) { {match: {name: 'name'}} }
-  let(:unexpected_query) { {match: {name: 'name'}} }
-
-  context 'build expected query' do
-    specify do
-      expect(CitiesIndex.query(dummy_query)).to build_query(expected_query)
-    end
-  end
-
-  context 'not to build unexpected query' do
-    specify do
-      expect(CitiesIndex.query(dummy_query)).not_to build_query(unexpected_query)
-    end
-  end
-end

data/spec/chewy/rspec/helpers_spec.rb

@@ -1,61 +0,0 @@
-require 'spec_helper'
-
-describe :rspec_helper do
-  include Chewy::Rspec::Helpers
-
-  before do
-    stub_model(:city)
-    stub_index(:cities) { index_scope City }
-    CitiesIndex.create
-  end
-
-  let(:hits) do
-    [
-      {
-        '_index' => 'cities',
-        '_type' => '_doc',
-        '_id' => '1',
-        '_score' => 3.14,
-        '_source' => source
-      }
-    ]
-  end
-
-  let(:source) { {'name' => 'some_name'} }
-  let(:sources) { [source] }
-
-  context :mock_elasticsearch_response do
-    let(:raw_response) do
-      {
-        'took' => 4,
-        'timed_out' => false,
-        '_shards' => {
-          'total' => 1,
-          'successful' => 1,
-          'skipped' => 0,
-          'failed' => 0
-        },
-        'hits' => {
-          'total' => {
-            'value' => 1,
-            'relation' => 'eq'
-          },
-          'max_score' => 1.0,
-          'hits' => hits
-        }
-      }
-    end
-
-    specify do
-      mock_elasticsearch_response(CitiesIndex, raw_response)
-      expect(CitiesIndex.query({}).hits).to eq(hits)
-    end
-  end
-
-  context :mock_elasticsearch_response_sources do
-    specify do
-      mock_elasticsearch_response_sources(CitiesIndex, sources)
-      expect(CitiesIndex.query({}).hits).to eq(hits)
-    end
-  end
-end

data/spec/chewy/rspec/update_index_spec.rb

@@ -1,313 +0,0 @@
-require 'spec_helper'
-
-describe :update_index do
-  before do
-    stub_index(:dummies) do
-    end
-    stub_index(:dummies2) do
-    end
-  end
-
-  before do
-    drop_indices
-    DummiesIndex.create!
-  end
-
-  specify { expect {}.not_to update_index(DummiesIndex) }
-  specify { expect { DummiesIndex.bulk body: [] }.not_to update_index(DummiesIndex) }
-
-  specify do
-    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.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
-    end.to update_index(DummiesIndex).and_reindex(41, 42).only
-  end
-
-  context do
-    let(:expectation) do
-      expect do
-        expect do
-          DummiesIndex.bulk body: [{index: {_id: 42}}, {index: {_id: 41}}, {index: {_id: 42}}]
-        end.not_to update_index(DummiesIndex)
-      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.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
-
-    context do
-      let(:expectation) do
-        expect do
-          expect do
-            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
-      end
-
-      specify { expectation.to fail_matching 'Expected index `DummiesIndex` to be updated' }
-    end
-  end
-
-  context '#only' do
-    specify do
-      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.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
-    specify do
-      expect do
-        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
-
-    specify do
-      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.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
-    specify do
-      expect do
-        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
-
-    specify do
-      expect do
-        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
-    specify do
-      expect do
-        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.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
-    specify do
-      expect do
-        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.bulk body: [{index: {_id: 42}}] }.to update_index(DummiesIndex) }
-    specify do
-      expect { DummiesIndex.bulk body: [{index: {_id: 42, data: {}}}] }
-        .to update_index(DummiesIndex).and_reindex(42)
-    end
-    specify do
-      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.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.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.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
-
-    context do
-      let(:expectation) do
-        expect do
-          expect do
-            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') }
-      specify { expectation.to fail_matching('Expected document with id `47` to be reindexed, but it was not') }
-    end
-
-    context ':times' do
-      specify do
-        expect do
-          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.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
-
-      context do
-        let(:expectation) do
-          expect do
-            expect do
-              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' }
-        specify { expectation.to fail_matching 'Expected document with id `43` to be reindexed' }
-        specify { expectation.to fail_matching '3 times, but was reindexed 1 times' }
-        specify { expectation.to fail_matching '4 times, but was reindexed 2 times' }
-      end
-    end
-
-    context ':with' do
-      specify do
-        expect do
-          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.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.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
-
-      [
-        [{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 do
-          expect do
-            DummiesIndex.bulk body: [{index: {_id: 42, data: data}}]
-          end.to update_index(DummiesIndex).and_reindex(42, with: with)
-        end
-      end
-
-      [
-        [{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 do
-          expect do
-            expect do
-              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
-
-      context do
-        let(:expectation) do
-          expect do
-            expect do
-              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' }
-        specify { expectation.to fail_matching '2 times, but was reindexed 1 times' }
-        specify { expectation.to fail_matching 'but it was reindexed with' }
-      end
-    end
-  end
-
-  context '#and_delete' do
-    specify do
-      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.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.bulk body: [{delete: {_id: 42}}, {delete: {_id: 43}}] }
-        .to update_index(DummiesIndex).and_delete(42, double(id: 43))
-    end
-    specify do
-      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.bulk body: [{index: {_id: 42, data: {}}}, {delete: {_id: 43}}] }
-            .to update_index(DummiesIndex).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' }
-      specify { expectation.to fail_matching 'Expected document with id `42` to be deleted, but it was not' }
-    end
-
-    context do
-      let(:expectation) do
-        expect do
-          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
-
-      specify { expectation.to fail_matching 'Expected document with id `44` to be deleted, but it was not' }
-      specify { expectation.to fail_matching 'Expected document with id `42` to be deleted' }
-      specify { expectation.to fail_matching '3 times, but was deleted 2 times' }
-    end
-  end
-end

data/spec/chewy/runtime/version_spec.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Runtime::Version do
-  describe '#major' do
-    specify { expect(described_class.new('1.2.3').major).to eq(1) }
-    specify { expect(described_class.new('1.2').major).to eq(1) }
-    specify { expect(described_class.new(1.2).major).to eq(1) }
-    specify { expect(described_class.new('1').major).to eq(1) }
-    specify { expect(described_class.new('').major).to eq(0) }
-  end
-
-  describe '#minor' do
-    specify { expect(described_class.new('1.2.3').minor).to eq(2) }
-    specify { expect(described_class.new('1.2').minor).to eq(2) }
-    specify { expect(described_class.new(1.2).minor).to eq(2) }
-    specify { expect(described_class.new('1').minor).to eq(0) }
-  end
-
-  describe '#patch' do
-    specify { expect(described_class.new('1.2.3').patch).to eq(3) }
-    specify { expect(described_class.new('1.2.3.pre1').patch).to eq(3) }
-    specify { expect(described_class.new('1.2').patch).to eq(0) }
-    specify { expect(described_class.new(1.2).patch).to eq(0) }
-  end
-
-  describe '#to_s' do
-    specify { expect(described_class.new('1.2.3').to_s).to eq('1.2.3') }
-    specify { expect(described_class.new('1.2.3.pre1').to_s).to eq('1.2.3') }
-    specify { expect(described_class.new('1.2').to_s).to eq('1.2.0') }
-    specify { expect(described_class.new(1.2).to_s).to eq('1.2.0') }
-    specify { expect(described_class.new('1').to_s).to eq('1.0.0') }
-    specify { expect(described_class.new('').to_s).to eq('0.0.0') }
-  end
-
-  describe '#<=>' do
-    specify { expect(described_class.new('1.2.3')).to eq('1.2.3') }
-    specify { expect(described_class.new('1.2.3')).to be < '1.2.4' }
-    specify { expect(described_class.new('1.2.3')).to be < '1.2.10' }
-    specify { expect(described_class.new('1.10.2')).to eq('1.10.2') }
-    specify { expect(described_class.new('1.10.2')).to be > '1.7.2' }
-    specify { expect(described_class.new('2.10.2')).to be > '1.7.2' }
-    specify { expect(described_class.new('1.10.2')).to be < '2.7.2' }
-    specify { expect(described_class.new('1.10.2')).to be < described_class.new('2.7.2') }
-    specify { expect(described_class.new('1.10.2')).to be < 2.7 }
-    specify { expect(described_class.new('1.10.2')).to be < 1.11 }
-    specify { expect(described_class.new('1.2.0')).to eq('1.2') }
-  end
-end

data/spec/chewy/runtime_spec.rb

@@ -1,9 +0,0 @@
-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 >= '8.0' }
-    specify { expect(described_class.version).to be < '9.0' }
-  end
-end

data/spec/chewy/search/loader_spec.rb

@@ -1,83 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Search::Loader do
-  before { drop_indices }
-
-  before do
-    stub_model(:city)
-    stub_model(:country)
-
-    stub_index(:cities) do
-      index_scope City
-      field :name
-      field :rating, type: 'integer'
-    end
-
-    stub_index(:countries) do
-      index_scope Country
-      field :name
-      field :rating, type: 'integer'
-    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_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_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_index('boro_goves')).to eq(CitiesIndex) }
-      specify { expect(subject.derive_index('boro_goves_suffix')).to eq(CitiesIndex) }
-    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 '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) { {countries: {scope: -> { where('rating > 2') }}} }
-        specify { expect(subject.load(hits)).to eq([*cities, nil, countries.last]) }
-      end
-    end
-
-    context 'objects' do
-      before do
-        stub_index(:cities) do
-          field :name
-          field :rating, type: 'integer'
-        end
-
-        stub_index(:countries) do
-          field :name
-          field :rating, type: 'integer'
-        end
-      end
-
-      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
-end

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

@@ -1,69 +0,0 @@
-require 'spec_helper'
-
-shared_examples :kaminari do |request_base_class|
-  before { drop_indices }
-
-  before do
-    stub_index(:products) do
-      field :name
-      field :age, type: 'integer'
-    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.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

@@ -1,21 +0,0 @@
-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.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

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

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