chewy 0.4.1 → 0.5.0

data/spec/chewy/index/search_spec.rb

@@ -1,8 +1,6 @@
 require 'spec_helper'
 
 describe Chewy::Index::Search do
-  include ClassHelpers
-
   before do
     stub_index(:products) do
       define_type :product
@@ -12,12 +10,6 @@ describe Chewy::Index::Search do
 
   let(:product) { ProductsIndex::Product }
 
-  describe '.all' do
-    specify { product.all.should be_a Chewy::Query }
-    specify { product.all.object_id.should_not == product.all.object_id }
-    specify { product.all.should == product.all }
-  end
-
   describe '.search_string' do
     specify do
       expect(ProductsIndex.client).to receive(:search).with(hash_including(q: 'hello')).twice

data/spec/chewy/index/settings_spec.rb

@@ -1,8 +1,6 @@
 require 'spec_helper'
 
 describe Chewy::Index::Settings do
-  include ClassHelpers
-
   describe '#to_hash' do
     before { Chewy.stub(config: Chewy::Config.send(:new)) }
 

data/spec/chewy/index_spec.rb

@@ -1,8 +1,6 @@
 require 'spec_helper'
 
 describe Chewy::Index do
-  include ClassHelpers
-
   before do
     stub_index(:dummies) do
       define_type :dummy

data/spec/chewy/query/criteria_spec.rb

@@ -1,32 +1,39 @@
 require 'spec_helper'
 
 describe Chewy::Query::Criteria do
-  include ClassHelpers
-
   subject { described_class.new }
 
   its(:options) { should be_a Hash }
+  its(:request_options) { should be_a Hash }
   its(:facets) { should == {} }
   its(:aggregations) { should == {} }
   its(:queries) { should == [] }
   its(:filters) { should == [] }
+  its(:post_filters) { should == [] }
   its(:sort) { should == [] }
   its(:fields) { should == [] }
   its(:types) { should == [] }
 
-  its(:none?){ should be_false }
+  its(:request_options?) { should be_false }
   its(:facets?) { should be_false }
   its(:aggregations?) { should be_false }
   its(:queries?) { should be_false }
   its(:filters?) { should be_false }
+  its(:post_filters?) { should be_false }
   its(:sort?) { should be_false }
   its(:fields?) { should be_false }
   its(:types?) { should be_false }
 
+  its(:none?){ should be_false }
+
   describe '#update_options' do
     specify { expect { subject.update_options(field: 'hello') }.to change { subject.options }.to(hash_including(field: 'hello')) }
   end
 
+  describe '#update_request_options' do
+    specify { expect { subject.update_request_options(field: 'hello') }.to change { subject.request_options }.to(hash_including(field: 'hello')) }
+  end
+
   describe '#update_facets' do
     specify { expect { subject.update_facets(field: 'hello') }.to change { subject.facets? }.to(true) }
     specify { expect { subject.update_facets(field: 'hello') }.to change { subject.facets }.to(field: 'hello') }
@@ -55,6 +62,15 @@ describe Chewy::Query::Criteria do
       .to change { subject.filters }.to([{field: 'hello'}, {field: 'world'}]) }
   end
 
+  describe '#update_post_filters' do
+    specify { expect { subject.update_post_filters(field: 'hello') }.to change { subject.post_filters? }.to(true) }
+    specify { expect { subject.update_post_filters(field: 'hello') }.to change { subject.post_filters }.to([{field: 'hello'}]) }
+    specify { expect { subject.update_post_filters(field: 'hello'); subject.update_post_filters(field: 'world') }
+      .to change { subject.post_filters }.to([{field: 'hello'}, {field: 'world'}]) }
+    specify { expect { subject.update_post_filters([{field: 'hello'}, {field: 'world'}, nil]) }
+      .to change { subject.post_filters }.to([{field: 'hello'}, {field: 'world'}]) }
+  end
+
   describe '#update_sort' do
     specify { expect { subject.update_sort(:field) }.to change { subject.sort? }.to(true) }
 
@@ -102,6 +118,8 @@ describe Chewy::Query::Criteria do
 
     specify { subject.tap { |c| c.update_options(opt1: 'hello') }
       .merge(criteria.tap { |c| c.update_options(opt2: 'hello') }).options.should include(opt1: 'hello', opt2: 'hello') }
+    specify { subject.tap { |c| c.update_request_options(opt1: 'hello') }
+      .merge(criteria.tap { |c| c.update_request_options(opt2: 'hello') }).request_options.should include(opt1: 'hello', opt2: 'hello') }
     specify { subject.tap { |c| c.update_facets(field1: 'hello') }
       .merge(criteria.tap { |c| c.update_facets(field1: 'hello') }).facets.should == {field1: 'hello', field1: 'hello'} }
     specify { subject.tap { |c| c.update_aggregations(field1: 'hello') }
@@ -110,6 +128,8 @@ describe Chewy::Query::Criteria do
       .merge(criteria.tap { |c| c.update_queries(field2: 'hello') }).queries.should == [{field1: 'hello'}, {field2: 'hello'}] }
     specify { subject.tap { |c| c.update_filters(field1: 'hello') }
       .merge(criteria.tap { |c| c.update_filters(field2: 'hello') }).filters.should == [{field1: 'hello'}, {field2: 'hello'}] }
+    specify { subject.tap { |c| c.update_post_filters(field1: 'hello') }
+      .merge(criteria.tap { |c| c.update_post_filters(field2: 'hello') }).post_filters.should == [{field1: 'hello'}, {field2: 'hello'}] }
     specify { subject.tap { |c| c.update_sort(:field1) }
       .merge(criteria.tap { |c| c.update_sort(:field2) }).sort.should == [:field1, :field2] }
     specify { subject.tap { |c| c.update_fields(:field1) }
@@ -126,6 +146,8 @@ describe Chewy::Query::Criteria do
 
     specify { subject.tap { |c| c.update_options(opt1: 'hello') }
       .merge!(criteria.tap { |c| c.update_options(opt2: 'hello') }).options.should include(opt1: 'hello', opt2: 'hello') }
+    specify { subject.tap { |c| c.update_request_options(opt1: 'hello') }
+      .merge!(criteria.tap { |c| c.update_request_options(opt2: 'hello') }).request_options.should include(opt1: 'hello', opt2: 'hello') }
     specify { subject.tap { |c| c.update_facets(field1: 'hello') }
       .merge!(criteria.tap { |c| c.update_facets(field1: 'hello') }).facets.should == {field1: 'hello', field1: 'hello'} }
     specify { subject.tap { |c| c.update_aggregations(field1: 'hello') }
@@ -134,6 +156,8 @@ describe Chewy::Query::Criteria do
       .merge!(criteria.tap { |c| c.update_queries(field2: 'hello') }).queries.should == [{field1: 'hello'}, {field2: 'hello'}] }
     specify { subject.tap { |c| c.update_filters(field1: 'hello') }
       .merge!(criteria.tap { |c| c.update_filters(field2: 'hello') }).filters.should == [{field1: 'hello'}, {field2: 'hello'}] }
+    specify { subject.tap { |c| c.update_post_filters(field1: 'hello') }
+      .merge!(criteria.tap { |c| c.update_post_filters(field2: 'hello') }).post_filters.should == [{field1: 'hello'}, {field2: 'hello'}] }
     specify { subject.tap { |c| c.update_sort(:field1) }
       .merge!(criteria.tap { |c| c.update_sort(:field2) }).sort.should == [:field1, :field2] }
     specify { subject.tap { |c| c.update_fields(:field1) }
@@ -149,39 +173,57 @@ describe Chewy::Query::Criteria do
     end
 
     specify { request_body.should == {body: {}} }
-    specify { request_body { update_options(size: 10) }.should == {body: {size: 10}} }
-    specify { request_body { update_options(from: 10) }.should == {body: {from: 10}} }
-    specify { request_body { update_options(explain: true) }.should == {body: {explain: true}} }
+    specify { request_body { update_request_options(size: 10) }.should == {body: {size: 10}} }
+    specify { request_body { update_request_options(from: 10) }.should == {body: {from: 10}} }
+    specify { request_body { update_request_options(explain: true) }.should == {body: {explain: true}} }
     specify { request_body { update_queries(:query) }.should == {body: {query: :query}} }
     specify { request_body {
-      update_options(from: 10); update_sort(:field); update_fields(:field); update_queries(:query)
+      update_request_options(from: 10); update_sort(:field); update_fields(:field); update_queries(:query)
     }.should == {body: {query: :query, from: 10, sort: [:field], _source: ['field']}} }
+
+    specify { request_body {
+      update_queries(:query); update_filters(:filters);
+    }.should == {body: {query: {filtered: {query: :query, filter: :filters}}}} }
+    specify { request_body {
+      update_queries(:query); update_post_filters(:post_filter);
+    }.should == {body: {query: :query, post_filter: :post_filter}} }
   end
 
-  describe '#_composed_query' do
-    def _composed_query &block
+  describe '#_filtered_query' do
+    def _filtered_query options = {}, &block
       subject.instance_exec(&block) if block
-      subject.send(:_composed_query, subject.send(:_request_query), subject.send(:_request_filter))
+      subject.send(:_filtered_query, subject.send(:_request_query), subject.send(:_request_filter), options)
     end
 
-    specify { _composed_query.should be_nil }
-    specify { _composed_query { update_queries(:query) }.should == {query: :query} }
-    specify { _composed_query { update_queries([:query1, :query2]) }
+    specify { _filtered_query.should == {} }
+    specify { _filtered_query { update_queries(:query) }.should == {query: :query} }
+    specify { _filtered_query(strategy: 'query_first') { update_queries(:query) }.should == {query: :query} }
+    specify { _filtered_query { update_queries([:query1, :query2]) }
       .should == {query: {bool: {must: [:query1, :query2]}}} }
-    specify { _composed_query { update_options(query_mode: :should); update_queries([:query1, :query2]) }
+    specify { _filtered_query { update_options(query_mode: :should); update_queries([:query1, :query2]) }
       .should == {query: {bool: {should: [:query1, :query2]}}} }
-    specify { _composed_query { update_options(query_mode: :dis_max); update_queries([:query1, :query2]) }
+    specify { _filtered_query { update_options(query_mode: :dis_max); update_queries([:query1, :query2]) }
       .should == {query: {dis_max: {queries: [:query1, :query2]}}} }
 
-    specify { _composed_query { update_filters([:filter1, :filter2]) }
+    specify { _filtered_query(strategy: 'query_first') { update_filters([:filter1, :filter2]) }
+      .should == {query: {filtered: {query: {match_all: {}}, filter: {and: [:filter1, :filter2]}, strategy: 'query_first'}}} }
+    specify { _filtered_query { update_filters([:filter1, :filter2]) }
       .should == {query: {filtered: {query: {match_all: {}}, filter: {and: [:filter1, :filter2]}}}} }
-    specify { _composed_query { update_filters([:filter1, :filter2]); update_queries([:query1, :query2]) }
+
+    specify { _filtered_query { update_filters([:filter1, :filter2]); update_queries([:query1, :query2]) }
       .should == {query: {filtered: {
         query: {bool: {must: [:query1, :query2]}},
         filter: {and: [:filter1, :filter2]}
       }}}
     }
-    specify { _composed_query {
+    specify { _filtered_query(strategy: 'query_first') { update_filters([:filter1, :filter2]); update_queries([:query1, :query2]) }
+      .should == {query: {filtered: {
+        query: {bool: {must: [:query1, :query2]}},
+        filter: {and: [:filter1, :filter2]},
+        strategy: 'query_first'
+      }}}
+    }
+    specify { _filtered_query {
         update_options(query_mode: :should); update_options(filter_mode: :or);
         update_filters([:filter1, :filter2]); update_queries([:query1, :query2])
       }.should == {query: {filtered: {
@@ -222,6 +264,31 @@ describe Chewy::Query::Criteria do
       .should == {and: [{or: [{type: {value: 'type1'}}, {type: {value: 'type2'}}]}, {bool: {should: [:filter1, :filter2]}}]} }
   end
 
+  describe '#_request_post_filter' do
+    def _request_post_filter &block
+      subject.instance_exec(&block) if block
+      subject.send(:_request_post_filter)
+    end
+
+    specify { _request_post_filter.should be_nil }
+
+    specify { _request_post_filter { update_post_filters([:post_filter1, :post_filter2]) }
+      .should == {and: [:post_filter1, :post_filter2]} }
+    specify { _request_post_filter { update_options(post_filter_mode: :or); update_post_filters([:post_filter1, :post_filter2]) }
+      .should == {or: [:post_filter1, :post_filter2]} }
+    specify { _request_post_filter { update_options(post_filter_mode: :must); update_post_filters([:post_filter1, :post_filter2]) }
+      .should == {bool: {must: [:post_filter1, :post_filter2]}} }
+    specify { _request_post_filter { update_options(post_filter_mode: :should); update_post_filters([:post_filter1, :post_filter2]) }
+      .should == {bool: {should: [:post_filter1, :post_filter2]}} }
+
+    context do
+      before { Chewy.stub(filter_mode: :or) }
+
+      specify { _request_post_filter { update_post_filters([:post_filter1, :post_filter2]) }
+        .should == {or: [:post_filter1, :post_filter2]} }
+    end
+  end
+
   describe '#_request_types' do
     def _request_types &block
       subject.instance_exec(&block) if block

data/spec/chewy/query/loading_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe Chewy::Query::Loading do
-  include ClassHelpers
   before { Chewy.client.indices.delete index: '*' }
 
   before do
@@ -26,13 +25,31 @@ describe Chewy::Query::Loading do
 
     before { PlacesIndex.import!(cities: cities, countries: countries) }
 
-    specify { PlacesIndex.order(:rating).limit(6).load.total_count.should == 12 }
-    specify { PlacesIndex.order(:rating).limit(6).load.should =~ cities.first(3) + countries.first(3) }
-    specify { PlacesIndex.order(:rating).limit(6).load(city: { scope: ->{ where('rating < 2') } })
-      .should =~ cities.first(2) + countries.first(3) + [nil] }
-    specify { PlacesIndex.order(:rating).limit(6).load(scope: ->{ where('rating < 2') })
-      .should =~ cities.first(2) + countries.first(2) + [nil, nil] }
-    specify { PlacesIndex.order(:rating).limit(6).load(city: { scope: City.where('rating < 2') })
-      .should =~ cities.first(2) + countries.first(3) + [nil] }
+    describe '#load' do
+      specify { PlacesIndex.order(:rating).limit(6).load.total_count.should == 12 }
+      specify { PlacesIndex.order(:rating).limit(6).load.should =~ cities.first(3) + countries.first(3) }
+
+      specify { PlacesIndex.order(:rating).limit(6).load(city: { scope: ->{ where('rating < 2') } })
+        .should =~ cities.first(2) + countries.first(3) + [nil] }
+      specify { PlacesIndex.limit(6).load(city: { scope: ->{ where('rating < 2') } }).order(:rating)
+        .should =~ cities.first(2) + countries.first(3) + [nil] }
+      specify { PlacesIndex.order(:rating).limit(6).load(scope: ->{ where('rating < 2') })
+        .should =~ cities.first(2) + countries.first(2) + [nil] * 2 }
+      specify { PlacesIndex.order(:rating).limit(6).load(city: { scope: City.where('rating < 2') })
+        .should =~ cities.first(2) + countries.first(3) + [nil] }
+    end
+
+    describe '#preload' do
+      specify { PlacesIndex.order(:rating).limit(6).preload(scope: ->{ where('rating < 2') })
+        .map(&:_object).should =~ cities.first(2) + countries.first(2) + [nil] * 2 }
+      specify { PlacesIndex.limit(6).preload(scope: ->{ where('rating < 2') }).order(:rating)
+        .map(&:_object).should =~ cities.first(2) + countries.first(2) + [nil] * 2 }
+      specify { PlacesIndex.order(:rating).limit(6).preload(only: :city, scope: ->{ where('rating < 2') })
+        .map(&:_object).should =~ cities.first(2) + [nil] * 4 }
+      specify { PlacesIndex.order(:rating).limit(6).preload(except: [:city], scope: ->{ where('rating < 2') })
+        .map(&:_object).should =~ countries.first(2) + [nil] * 4 }
+      specify { PlacesIndex.order(:rating).limit(6).preload(only: [:city], except: :city, scope: ->{ where('rating < 2') })
+        .map(&:_object).should =~ [nil] * 6 }
+    end
   end
 end

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

@@ -7,10 +7,10 @@ describe Chewy::Query::Nodes::And do
     end
 
     specify { render { name? & (email == 'email') }.should == {
-      and: [{exists: {term: 'name'}}, {term: {'email' => 'email'}}]
+      and: [{exists: {field: 'name'}}, {term: {'email' => 'email'}}]
     } }
     specify { render { ~(name? & (email == 'email')) }.should == {
-      and: {filters: [{exists: {term: 'name'}}, {term: {'email' => 'email'}}], _cache: true}
+      and: {filters: [{exists: {field: 'name'}}, {term: {'email' => 'email'}}], _cache: true}
     } }
   end
 end

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

@@ -6,13 +6,13 @@ describe Chewy::Query::Nodes::Exists do
       Chewy::Query::Filters.new(&block).__render__
     end
 
-    specify { render { name? }.should == {exists: {term: 'name'}} }
+    specify { render { name? }.should == {exists: {field: 'name'}} }
 
-    specify { render { !!name? }.should == {exists: {term: 'name'}} }
-    specify { render { !!name }.should == {exists: {term: 'name'}} }
-    specify { render { name != nil }.should == {exists: {term: 'name'}} }
-    specify { render { !(name == nil) }.should == {exists: {term: 'name'}} }
+    specify { render { !!name? }.should == {exists: {field: 'name'}} }
+    specify { render { !!name }.should == {exists: {field: 'name'}} }
+    specify { render { name != nil }.should == {exists: {field: 'name'}} }
+    specify { render { !(name == nil) }.should == {exists: {field: 'name'}} }
 
-    specify { render { ~name? }.should == {exists: {term: 'name'}} }
+    specify { render { ~name? }.should == {exists: {field: 'name'}} }
   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: {term: 'name', existence: true, null_value: false}} }
-    specify { render { !name? }.should == {missing: {term: 'name', existence: true, null_value: true}} }
-    specify { render { name == nil }.should == {missing: {term: 'name', existence: false, null_value: true}} }
+    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 { render { ~!name }.should == {missing: {term: 'name', existence: true, null_value: false}} }
+    specify { render { ~!name }.should == {missing: {field: 'name', existence: true, null_value: false}} }
   end
 end

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

@@ -7,10 +7,10 @@ describe Chewy::Query::Nodes::Or do
     end
 
     specify { render { name? | (email == 'email') }.should == {
-      or: [{exists: {term: 'name'}}, {term: {'email' => 'email'}}]
+      or: [{exists: {field: 'name'}}, {term: {'email' => 'email'}}]
     } }
     specify { render { ~(name? | (email == 'email')) }.should == {
-      or: {filters: [{exists: {term: 'name'}}, {term: {'email' => 'email'}}], _cache: true}
+      or: {filters: [{exists: {field: 'name'}}, {term: {'email' => 'email'}}], _cache: true}
     } }
   end
 end

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

@@ -0,0 +1,55 @@
+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'
+      end
+    end
+  end
+
+  let(:search) { ProductsIndex.order(:age) }
+
+  specify { search.total_pages.should == 0 }
+
+  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) }
+
+    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 '#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_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 '#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 }
+
+      specify { search.per(4).page(1).load.total_count.should == 10 }
+      specify { search.per(2).page(3).load.total_pages.should == 5 }
+    end
+  end
+end

data/spec/chewy/query/pagination_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe Chewy::Query::Pagination do
-  include ClassHelpers
   before { Chewy.client.indices.delete index: '*' }
 
   before do
@@ -12,31 +11,25 @@ describe Chewy::Query::Pagination do
       end
     end
   end
-  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) }
 
   let(:search) { ProductsIndex.order(:age) }
 
-  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
+  specify { search.total_count.should == 0 }
 
-  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
+  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) }) }
 
-  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 }
+    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 }
+    end
+
+    describe '#load' do
+      specify { search.load.total_count.should == 10 }
+      specify { search.limit(5).load.total_count.should == 10 }
+    end
   end
 end