chewy 0.5.2 → 0.6.0

data/spec/chewy/query/nodes/has_parent_spec.rb

@@ -6,35 +6,35 @@ describe Chewy::Query::Nodes::HasParent do
       Chewy::Query::Filters.new(&block).__render__
     end
 
-    specify { render { has_parent('child') }.should == {has_parent: {type: 'child'}} }
-
-
-    specify { render { has_parent('child').filter(term: {name: 'name'}) }
-      .should == {has_parent: {type: 'child', filter: {term: {name: 'name'}}}} }
-    specify { render { has_parent('child').filter{ name == 'name' } }
-      .should == {has_parent: {type: 'child', filter: {term: {'name' => 'name'}}}} }
-    specify { render { has_parent('child').filter(term: {name: 'name'}).filter{ age < 42 } }
-      .should == {has_parent: {type: 'child', filter: {and: [{term: {name: 'name'}}, range: {'age' => {lt: 42}}]}}} }
-    specify { render { has_parent('child').filter(term: {name: 'name'}).filter{ age < 42 }.filter_mode(:or) }
-      .should == {has_parent: {type: 'child', filter: {or: [{term: {name: 'name'}}, range: {'age' => {lt: 42}}]}}} }
-
-    specify { render { has_parent('child').query(match: {name: 'name'}) }
-      .should == {has_parent: {type: 'child', query: {match: {name: 'name'}}}} }
-    specify { render { has_parent('child').query(match: {name: 'name'}).query(match: {surname: 'surname'}) }
-      .should == {has_parent: {type: 'child', query: {bool: {must: [{match: {name: 'name'}}, {match: {surname: 'surname'}}]}}}} }
-    specify { render { has_parent('child').query(match: {name: 'name'}).query(match: {surname: 'surname'}).query_mode(:should) }
-      .should == {has_parent: {type: 'child', query: {bool: {should: [{match: {name: 'name'}}, {match: {surname: 'surname'}}]}}}} }
-
-    specify { render { has_parent('child').filter{ name == 'name' }.query(match: {name: 'name'}) }
-      .should == {has_parent: {type: 'child', query: {filtered: {query: {match: {name: 'name'}}, filter: {term: {'name' => 'name'}}}}}} }
-    specify { render { has_parent('child').filter{ name == 'name' }.query(match: {name: 'name'}).filter{ age < 42 } }
-      .should == {has_parent: {type: 'child', query: {filtered: {query: {match: {name: 'name'}}, filter: {and: [{term: {'name' => 'name'}}, range: {'age' => {lt: 42}}]}}}}} }
+    specify { expect(render { has_parent('child') }).to eq({has_parent: {type: 'child'}}) }
+
+
+    specify { expect(render { has_parent('child').filter(term: {name: 'name'}) })
+      .to eq({has_parent: {type: 'child', filter: {term: {name: 'name'}}}}) }
+    specify { expect(render { has_parent('child').filter{ name == 'name' } })
+      .to eq({has_parent: {type: 'child', filter: {term: {'name' => 'name'}}}}) }
+    specify { expect(render { has_parent('child').filter(term: {name: 'name'}).filter{ age < 42 } })
+      .to eq({has_parent: {type: 'child', filter: {and: [{term: {name: 'name'}}, range: {'age' => {lt: 42}}]}}}) }
+    specify { expect(render { has_parent('child').filter(term: {name: 'name'}).filter{ age < 42 }.filter_mode(:or) })
+      .to eq({has_parent: {type: 'child', filter: {or: [{term: {name: 'name'}}, range: {'age' => {lt: 42}}]}}}) }
+
+    specify { expect(render { has_parent('child').query(match: {name: 'name'}) })
+      .to eq({has_parent: {type: 'child', query: {match: {name: 'name'}}}}) }
+    specify { expect(render { has_parent('child').query(match: {name: 'name'}).query(match: {surname: 'surname'}) })
+      .to eq({has_parent: {type: 'child', query: {bool: {must: [{match: {name: 'name'}}, {match: {surname: 'surname'}}]}}}}) }
+    specify { expect(render { has_parent('child').query(match: {name: 'name'}).query(match: {surname: 'surname'}).query_mode(:should) })
+      .to eq({has_parent: {type: 'child', query: {bool: {should: [{match: {name: 'name'}}, {match: {surname: 'surname'}}]}}}}) }
+
+    specify { expect(render { has_parent('child').filter{ name == 'name' }.query(match: {name: 'name'}) })
+      .to eq({has_parent: {type: 'child', query: {filtered: {query: {match: {name: 'name'}}, filter: {term: {'name' => 'name'}}}}}}) }
+    specify { expect(render { has_parent('child').filter{ name == 'name' }.query(match: {name: 'name'}).filter{ age < 42 } })
+      .to eq({has_parent: {type: 'child', query: {filtered: {query: {match: {name: 'name'}}, filter: {and: [{term: {'name' => 'name'}}, range: {'age' => {lt: 42}}]}}}}}) }
 
     context do
       let(:name) { 'Name' }
 
-      specify { render { has_parent('child').filter{ name == o{name} } }
-       .should == {has_parent: {type: 'child', filter: {term: {'name' => 'Name'}}}} }
+      specify { expect(render { has_parent('child').filter{ name == o{name} } })
+       .to eq({has_parent: {type: 'child', filter: {term: {'name' => 'Name'}}}}) }
     end
   end
 end

data/spec/chewy/query/nodes/match_all_spec.rb

@@ -6,6 +6,6 @@ describe Chewy::Query::Nodes::MatchAll do
       Chewy::Query::Filters.new(&block).__render__
     end
 
-    specify { render { match_all }.should == {match_all: {}} }
+    specify { expect(render { match_all }).to eq({match_all: {}}) }
   end
 end

data/spec/chewy/query/nodes/missing_spec.rb

@@ -6,10 +6,10 @@ describe Chewy::Query::Nodes::Missing do
       Chewy::Query::Filters.new(&block).__render__
     end
 
-    specify { render { !name }.should == {missing: {field: 'name', existence: true, null_value: false}} }
-    specify { render { !name? }.should == {missing: {field: 'name', existence: true, null_value: true}} }
-    specify { render { name == nil }.should == {missing: {field: 'name', existence: false, null_value: true}} }
+    specify { expect(render { !name }).to eq({missing: {field: 'name', existence: true, null_value: false}}) }
+    specify { expect(render { !name? }).to eq({missing: {field: 'name', existence: true, null_value: true}}) }
+    specify { expect(render { name == nil }).to eq({missing: {field: 'name', existence: false, null_value: true}}) }
 
-    specify { render { ~!name }.should == {missing: {field: 'name', existence: true, null_value: false}} }
+    specify { expect(render { ~!name }).to eq({missing: {field: 'name', existence: true, null_value: false}}) }
   end
 end

data/spec/chewy/query/nodes/not_spec.rb

@@ -6,11 +6,11 @@ describe Chewy::Query::Nodes::Not do
       Chewy::Query::Filters.new(&block).__render__
     end
 
-    specify { render { !(email == 'email') }.should == {
+    specify { expect(render { !(email == 'email') }).to eq({
       not: {term: {'email' => 'email'}}
-    } }
-    specify { render { ~!(email == 'email') }.should == {
+    }) }
+    specify { expect(render { ~!(email == 'email') }).to eq({
       not: {filter: {term: {'email' => 'email'}}, _cache: true}
-    } }
+    }) }
   end
 end

data/spec/chewy/query/nodes/or_spec.rb

@@ -6,11 +6,11 @@ describe Chewy::Query::Nodes::Or do
       Chewy::Query::Filters.new(&block).__render__
     end
 
-    specify { render { name? | (email == 'email') }.should == {
+    specify { expect(render { name? | (email == 'email') }).to eq({
       or: [{exists: {field: 'name'}}, {term: {'email' => 'email'}}]
-    } }
-    specify { render { ~(name? | (email == 'email')) }.should == {
+    }) }
+    specify { expect(render { ~(name? | (email == 'email')) }).to eq({
       or: {filters: [{exists: {field: 'name'}}, {term: {'email' => 'email'}}], _cache: true}
-    } }
+    }) }
   end
 end

data/spec/chewy/query/nodes/prefix_spec.rb

@@ -6,11 +6,11 @@ describe Chewy::Query::Nodes::Prefix do
       Chewy::Query::Filters.new(&block).__render__
     end
 
-    specify { render { name =~ 'nam' }.should == {prefix: {'name' => 'nam'}} }
-    specify { render { name !~ 'nam' }.should == {not: {prefix: {'name' => 'nam'}}} }
+    specify { expect(render { name =~ 'nam' }).to eq({prefix: {'name' => 'nam'}}) }
+    specify { expect(render { name !~ 'nam' }).to eq({not: {prefix: {'name' => 'nam'}}}) }
 
-    specify { render { ~name =~ 'nam' }.should == {prefix: {'name' => 'nam', _cache: true}} }
-    specify { render { ~name !~ 'nam' }.should == {not: {prefix: {'name' => 'nam', _cache: true}}} }
-    specify { render { name(cache: false) =~ 'nam' }.should == {prefix: {'name' => 'nam', _cache: false}} }
+    specify { expect(render { ~name =~ 'nam' }).to eq({prefix: {'name' => 'nam', _cache: true}}) }
+    specify { expect(render { ~name !~ 'nam' }).to eq({not: {prefix: {'name' => 'nam', _cache: true}}}) }
+    specify { expect(render { name(cache: false) =~ 'nam' }).to eq({prefix: {'name' => 'nam', _cache: false}}) }
   end
 end

data/spec/chewy/query/nodes/query_spec.rb

@@ -6,7 +6,7 @@ describe Chewy::Query::Nodes::Query do
       Chewy::Query::Filters.new(&block).__render__
     end
 
-    specify { render { q(query_string: {query: 'name: hello'}) }.should == {query: {query_string: {query: 'name: hello'}}} }
-    specify { render { ~q(query_string: {query: 'name: hello'}) }.should == {fquery: {query: {query_string: {query: 'name: hello'}}, _cache: true}} }
+    specify { expect(render { q(query_string: {query: 'name: hello'}) }).to eq({query: {query_string: {query: 'name: hello'}}}) }
+    specify { expect(render { ~q(query_string: {query: 'name: hello'}) }).to eq({fquery: {query: {query_string: {query: 'name: hello'}}, _cache: true}}) }
   end
 end

data/spec/chewy/query/nodes/range_spec.rb

@@ -6,27 +6,27 @@ describe Chewy::Query::Nodes::Range do
       Chewy::Query::Filters.new(&block).__render__
     end
 
-    specify { render { age > nil }.should == {range: {'age' => {gt: nil}}} }
-    specify { render { age == (nil..nil) }.should == {range: {'age' => {gt: nil, lt: nil}}} }
+    specify { expect(render { age > nil }).to eq({range: {'age' => {gt: nil}}}) }
+    specify { expect(render { age == (nil..nil) }).to eq({range: {'age' => {gt: nil, lt: nil}}}) }
 
-    specify { render { age > 42 }.should == {range: {'age' => {gt: 42}}} }
-    specify { render { age == (42..45) }.should == {range: {'age' => {gt: 42, lt: 45}}} }
-    specify { render { age == [42..45] }.should == {range: {'age' => {gte: 42, lte: 45}}} }
-    specify { render { (age > 42) & (age <= 45) }.should == {range: {'age' => {gt: 42, lte: 45}}} }
+    specify { expect(render { age > 42 }).to eq({range: {'age' => {gt: 42}}}) }
+    specify { expect(render { age == (42..45) }).to eq({range: {'age' => {gt: 42, lt: 45}}}) }
+    specify { expect(render { age == [42..45] }).to eq({range: {'age' => {gte: 42, lte: 45}}}) }
+    specify { expect(render { (age > 42) & (age <= 45) }).to eq({range: {'age' => {gt: 42, lte: 45}}}) }
 
-    specify { render { ~age > 42 }.should == {range: {'age' => {gt: 42}, _cache: true}} }
-    specify { render { ~age == (42..45) }.should == {range: {'age' => {gt: 42, lt: 45}, _cache: true}} }
-    specify { render { ~age == [42..45] }.should == {range: {'age' => {gte: 42, lte: 45}, _cache: true}} }
-    specify { render { (age > 42) & ~(age <= 45) }.should == {range: {'age' => {gt: 42, lte: 45}, _cache: true}} }
-    specify { render { (~age > 42) & (age <= 45) }.should == {range: {'age' => {gt: 42, lte: 45}, _cache: true}} }
+    specify { expect(render { ~age > 42 }).to eq({range: {'age' => {gt: 42}, _cache: true}}) }
+    specify { expect(render { ~age == (42..45) }).to eq({range: {'age' => {gt: 42, lt: 45}, _cache: true}}) }
+    specify { expect(render { ~age == [42..45] }).to eq({range: {'age' => {gte: 42, lte: 45}, _cache: true}}) }
+    specify { expect(render { (age > 42) & ~(age <= 45) }).to eq({range: {'age' => {gt: 42, lte: 45}, _cache: true}}) }
+    specify { expect(render { (~age > 42) & (age <= 45) }).to eq({range: {'age' => {gt: 42, lte: 45}, _cache: true}}) }
 
-    specify { render { age(:i) > 42 }.should == {range: {'age' => {gt: 42}, execution: :index}} }
-    specify { render { age(:index) > 42 }.should == {range: {'age' => {gt: 42}, execution: :index}} }
-    specify { render { age(:f) > 42 }.should == {range: {'age' => {gt: 42}, execution: :fielddata}} }
-    specify { render { age(:fielddata) > 42 }.should == {range: {'age' => {gt: 42}, execution: :fielddata}} }
-    specify { render { (age(:f) > 42) & (age <= 45) }.should == {range: {'age' => {gt: 42, lte: 45}, execution: :fielddata}} }
+    specify { expect(render { age(:i) > 42 }).to eq({range: {'age' => {gt: 42}, execution: :index}}) }
+    specify { expect(render { age(:index) > 42 }).to eq({range: {'age' => {gt: 42}, execution: :index}}) }
+    specify { expect(render { age(:f) > 42 }).to eq({range: {'age' => {gt: 42}, execution: :fielddata}}) }
+    specify { expect(render { age(:fielddata) > 42 }).to eq({range: {'age' => {gt: 42}, execution: :fielddata}}) }
+    specify { expect(render { (age(:f) > 42) & (age <= 45) }).to eq({range: {'age' => {gt: 42, lte: 45}, execution: :fielddata}}) }
 
-    specify { render { ~age(:f) > 42 }.should == {range: {'age' => {gt: 42}, execution: :fielddata, _cache: true}} }
-    specify { render { (age(:f) > 42) & (~age <= 45) }.should == {range: {'age' => {gt: 42, lte: 45}, execution: :fielddata, _cache: true}} }
+    specify { expect(render { ~age(:f) > 42 }).to eq({range: {'age' => {gt: 42}, execution: :fielddata, _cache: true}}) }
+    specify { expect(render { (age(:f) > 42) & (~age <= 45) }).to eq({range: {'age' => {gt: 42, lte: 45}, execution: :fielddata, _cache: true}}) }
   end
 end

data/spec/chewy/query/nodes/raw_spec.rb

@@ -6,6 +6,6 @@ describe Chewy::Query::Nodes::Raw do
       Chewy::Query::Filters.new(&block).__render__
     end
 
-    specify { render { r(term: {name: 'name'}) }.should == {term: {name: 'name'}} }
+    specify { expect(render { r(term: {name: 'name'}) }).to eq({term: {name: 'name'}}) }
   end
 end

data/spec/chewy/query/nodes/regexp_spec.rb

@@ -6,26 +6,26 @@ describe Chewy::Query::Nodes::Regexp do
       Chewy::Query::Filters.new(&block).__render__
     end
 
-    specify { render { names.first == /nam.*/ }.should == {regexp: {'names.first' => 'nam.*'}} }
-    specify { render { names.first =~ /nam.*/ }.should == {regexp: {'names.first' => 'nam.*'}} }
-    specify { render { name != /nam.*/ }.should == {not: {regexp: {'name' => 'nam.*'}}} }
-    specify { render { name !~ /nam.*/ }.should == {not: {regexp: {'name' => 'nam.*'}}} }
+    specify { expect(render { names.first == /nam.*/ }).to eq({regexp: {'names.first' => 'nam.*'}}) }
+    specify { expect(render { names.first =~ /nam.*/ }).to eq({regexp: {'names.first' => 'nam.*'}}) }
+    specify { expect(render { name != /nam.*/ }).to eq({not: {regexp: {'name' => 'nam.*'}}}) }
+    specify { expect(render { name !~ /nam.*/ }).to eq({not: {regexp: {'name' => 'nam.*'}}}) }
 
-    specify { render { names.first(flags: [:anystring, :intersection, :borogoves]) == /nam.*/ }
-      .should == {regexp: {'names.first' => {value: 'nam.*', flags: 'ANYSTRING|INTERSECTION'}}} }
-    specify { render { names.first(:anystring, :intersection, :borogoves) == /nam.*/ }
-      .should == {regexp: {'names.first' => {value: 'nam.*', flags: 'ANYSTRING|INTERSECTION'}}} }
+    specify { expect(render { names.first(flags: [:anystring, :intersection, :borogoves]) == /nam.*/ })
+      .to eq({regexp: {'names.first' => {value: 'nam.*', flags: 'ANYSTRING|INTERSECTION'}}}) }
+    specify { expect(render { names.first(:anystring, :intersection, :borogoves) == /nam.*/ })
+      .to eq({regexp: {'names.first' => {value: 'nam.*', flags: 'ANYSTRING|INTERSECTION'}}}) }
 
-    specify { render { names.first(flags: [:anystring, :intersection, :borogoves]) =~ /nam.*/ }
-      .should == {regexp: {'names.first' => {value: 'nam.*', flags: 'ANYSTRING|INTERSECTION'}}} }
-    specify { render { names.first(:anystring, :intersection, :borogoves) =~ /nam.*/ }
-      .should == {regexp: {'names.first' => {value: 'nam.*', flags: 'ANYSTRING|INTERSECTION'}}} }
+    specify { expect(render { names.first(flags: [:anystring, :intersection, :borogoves]) =~ /nam.*/ })
+      .to eq({regexp: {'names.first' => {value: 'nam.*', flags: 'ANYSTRING|INTERSECTION'}}}) }
+    specify { expect(render { names.first(:anystring, :intersection, :borogoves) =~ /nam.*/ })
+      .to eq({regexp: {'names.first' => {value: 'nam.*', flags: 'ANYSTRING|INTERSECTION'}}}) }
 
-    specify { render { ~names.first == /nam.*/ }.should == {regexp: {'names.first' => 'nam.*', _cache: true, _cache_key: 'nam.*'}} }
-    specify { render { names.first(cache: 'name') == /nam.*/ }.should == {regexp: {'names.first' => 'nam.*', _cache: true, _cache_key: 'name'}} }
-    specify { render { ~names.first(:anystring) =~ /nam.*/ }
-      .should == {regexp: {'names.first' => {value: 'nam.*', flags: 'ANYSTRING'}, _cache: true, _cache_key: 'nam.*'}} }
-    specify { render { names.first(:anystring, cache: 'name') =~ /nam.*/ }
-      .should == {regexp: {'names.first' => {value: 'nam.*', flags: 'ANYSTRING'}, _cache: true, _cache_key: 'name'}} }
+    specify { expect(render { ~names.first == /nam.*/ }).to eq({regexp: {'names.first' => 'nam.*', _cache: true, _cache_key: 'nam.*'}}) }
+    specify { expect(render { names.first(cache: 'name') == /nam.*/ }).to eq({regexp: {'names.first' => 'nam.*', _cache: true, _cache_key: 'name'}}) }
+    specify { expect(render { ~names.first(:anystring) =~ /nam.*/ })
+      .to eq({regexp: {'names.first' => {value: 'nam.*', flags: 'ANYSTRING'}, _cache: true, _cache_key: 'nam.*'}}) }
+    specify { expect(render { names.first(:anystring, cache: 'name') =~ /nam.*/ })
+      .to eq({regexp: {'names.first' => {value: 'nam.*', flags: 'ANYSTRING'}, _cache: true, _cache_key: 'name'}}) }
   end
 end

data/spec/chewy/query/nodes/script_spec.rb

@@ -6,10 +6,10 @@ describe Chewy::Query::Nodes::Script do
       Chewy::Query::Filters.new(&block).__render__
     end
 
-    specify { render { s('var = val') }.should == {script: {script: 'var = val'}} }
-    specify { render { s('var = val', val: 42) }.should == {script: {script: 'var = val', params: {val: 42}}} }
+    specify { expect(render { s('var = val') }).to eq({script: {script: 'var = val'}}) }
+    specify { expect(render { s('var = val', val: 42) }).to eq({script: {script: 'var = val', params: {val: 42}}}) }
 
-    specify { render { ~s('var = val') }.should == {script: {script: 'var = val', _cache: true}} }
-    specify { render { ~s('var = val', val: 42) }.should == {script: {script: 'var = val', params: {val: 42}, _cache: true}} }
+    specify { expect(render { ~s('var = val') }).to eq({script: {script: 'var = val', _cache: true}}) }
+    specify { expect(render { ~s('var = val', val: 42) }).to eq({script: {script: 'var = val', params: {val: 42}, _cache: true}}) }
   end
 end

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

@@ -1,55 +1,57 @@
 require 'spec_helper'
 
-describe Chewy::Query::Pagination::Kaminari do
-  before { Chewy.client.indices.delete index: '*' }
-
-  before do
-    stub_index(:products) do
-      define_type(:product) do
-        field :name
-        field :age, type: 'integer'
+if defined?(::Kaminari)
+  describe Chewy::Query::Pagination::Kaminari do
+    before { Chewy.massacre }
+
+    before do
+      stub_index(:products) do
+        define_type(:product) do
+          field :name
+          field :age, type: 'integer'
+        end
       end
     end
-  end
 
-  let(:search) { ProductsIndex.order(:age) }
+    let(:search) { ProductsIndex.order(:age) }
 
-  specify { search.total_pages.should == 0 }
+    specify { expect(search.total_pages).to eq(0) }
 
-  context do
-    let(:data) { 10.times.map { |i| {id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next}.stringify_keys! } }
+    context do
+      let(:data) { 10.times.map { |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 { ::Kaminari.config.stub(default_per_page: 3) }
+      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 { search.map { |e| e.attributes.except('_score', '_explanation') }.should =~ data }
-      specify { search.page(1).map { |e| e.attributes.except('_score', '_explanation') }.should == data[0..2] }
-      specify { search.page(2).map { |e| e.attributes.except('_score', '_explanation') }.should == data[3..5] }
-      specify { search.page(2).per(4).map { |e| e.attributes.except('_score', '_explanation') }.should == data[4..7] }
-      specify { search.per(2).page(3).map { |e| e.attributes.except('_score', '_explanation') }.should == data[4..5] }
-      specify { search.per(5).page.map { |e| e.attributes.except('_score', '_explanation') }.should == data[0..4] }
-      specify { search.page.per(4).map { |e| e.attributes.except('_score', '_explanation') }.should == data[0..3] }
-    end
+      describe '#per, #page' do
+        specify { expect(search.map { |e| e.attributes.except('_score', '_explanation') }).to match_array(data) }
+        specify { expect(search.page(1).map { |e| e.attributes.except('_score', '_explanation') }).to eq(data[0..2]) }
+        specify { expect(search.page(2).map { |e| e.attributes.except('_score', '_explanation') }).to eq(data[3..5]) }
+        specify { expect(search.page(2).per(4).map { |e| e.attributes.except('_score', '_explanation') }).to eq(data[4..7]) }
+        specify { expect(search.per(2).page(3).map { |e| e.attributes.except('_score', '_explanation') }).to eq(data[4..5]) }
+        specify { expect(search.per(5).page.map { |e| e.attributes.except('_score', '_explanation') }).to eq(data[0..4]) }
+        specify { expect(search.page.per(4).map { |e| e.attributes.except('_score', '_explanation') }).to eq(data[0..3]) }
+      end
 
-    describe '#total_pages' do
-      specify { search.total_pages.should == 4 }
-      specify { search.per(5).page(2).total_pages.should == 2 }
-      specify { search.per(2).page(3).total_pages.should == 5 }
-    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 { search.per(4).page(1).total_count.should == 10 }
-      specify { search.filter(numeric_range: {age: {gt: 20}}).limit(3).total_count.should == 8 }
-    end
+      describe '#total_count' do
+        specify { expect(search.per(4).page(1).total_count).to eq(10) }
+        specify { expect(search.filter(numeric_range: {age: {gt: 20}}).limit(3).total_count).to eq(8) }
+      end
 
-    describe '#load' do
-      specify { search.per(2).page(1).load.first.age.should == 10 }
-      specify { search.per(2).page(3).load.first.age.should == 50 }
-      specify { search.per(2).page(3).load.page(2).load.first.age.should == 30 }
+      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 { search.per(4).page(1).load.total_count.should == 10 }
-      specify { search.per(2).page(3).load.total_pages.should == 5 }
+        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
     end
   end
 end

data/spec/chewy/query/pagination/will_paginage_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+
+if defined?(::WillPaginate)
+  describe Chewy::Query::Pagination::WillPaginate do
+    before { Chewy.massacre }
+
+    before do
+      stub_index(:products) do
+        define_type(:product) do
+          field :name
+          field :age, type: 'integer'
+        end
+      end
+    end
+
+    let(:search) { ProductsIndex.order(:age) }
+
+    specify { expect(search.total_pages).to eq(1) } #defaults to 1 on will_paginate
+
+    context do
+      let(:data) { 10.times.map { |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) }
+
+      describe '#page' do
+        specify { expect(search.map { |e| e.attributes.except('_score', '_explanation') }).to match_array(data) }
+        specify { expect(search.page(1).map { |e| e.attributes.except('_score', '_explanation') }).to eq(data[0..2]) }
+        specify { expect(search.page(2).map { |e| e.attributes.except('_score', '_explanation') }).to eq(data[3..5]) }
+      end
+
+      describe "#paginate" do
+        specify { expect(search.paginate(page: 2, per_page: 4).map { |e| e.attributes.except('_score', '_explanation') }).to eq(data[4..7]) }
+        specify { expect(search.paginate(per_page: 2, page: 3).page(3).map { |e| e.attributes.except('_score', '_explanation') }).to eq(data[4..5]) }
+        specify { expect(search.paginate(per_page: 5).map { |e| e.attributes.except('_score', '_explanation') }).to eq(data[0..4]) }
+        specify { expect(search.paginate(per_page: 4).map { |e| e.attributes.except('_score', '_explanation') }).to eq(data[0..3]) }
+      end
+
+      describe '#total_pages' do
+        specify { expect(search.paginate(page: 2, per_page: 5).total_pages).to eq(2) }
+        specify { expect(search.paginate(page: 3, per_page: 2).total_pages).to eq(5) }
+      end
+
+      describe '#total_entries' do
+        specify { expect(search.paginate(page: 1, per_page: 4).total_entries).to eq(10) }
+        specify { expect(search.filter(numeric_range: {age: {gt: 20}}).limit(3).total_entries).to eq(8) }
+      end
+
+      describe '#load' do
+        specify { expect(search.paginate(per_page: 2, page: 1).load.first.age).to eq(10) }
+        specify { expect(search.paginate(per_page: 2, page: 3).load.first.age).to eq(50) }
+        specify { expect(search.paginate(per_page: 2, page: 3).load.page(2).load.first.age).to eq(30) }
+
+        specify { expect(search.paginate(per_page:4, page:1).load.total_count).to eq(10) }
+        specify { expect(search.paginate(per_page:2, page:3).load.total_pages).to eq(5) }
+      end
+    end
+  end
+end

data/spec/chewy/query/pagination_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Chewy::Query::Pagination do
-  before { Chewy.client.indices.delete index: '*' }
+  before { Chewy.massacre }
 
   before do
     stub_index(:products) do
@@ -14,7 +14,7 @@ describe Chewy::Query::Pagination do
 
   let(:search) { ProductsIndex.order(:age) }
 
-  specify { search.total_count.should == 0 }
+  specify { expect(search.total_count).to eq(0) }
 
   context do
     let(:data) { 10.times.map { |i| {id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next}.stringify_keys! } }
@@ -22,14 +22,15 @@ describe Chewy::Query::Pagination do
     before { ProductsIndex::Product.import!(data.map { |h| double(h) }) }
 
     describe '#total_count' do
-      specify { search.total_count.should == 10 }
-      specify { search.limit(5).total_count.should == 10 }
-      specify { search.filter(numeric_range: {age: {gt: 20}}).limit(3).total_count.should == 8 }
+      specify { expect(search.total_count).to eq(10) }
+      specify { expect(search.limit(5).total_count).to eq(10) }
+      specify { expect(search.filter(numeric_range: {age: {gt: 20}}).limit(3).total_count).to eq(8) }
     end
 
     describe '#load' do
-      specify { search.load.total_count.should == 10 }
-      specify { search.limit(5).load.total_count.should == 10 }
+      specify { expect(search.load.total_count).to eq(10) }
+      specify { expect(search.limit(5).load.total_count).to eq(10) }
     end
   end
+
 end