chewy 0.8.4 → 7.3.4

data/spec/chewy/query/loading_spec.rb

@@ -1,86 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Query::Loading, :orm do
-  before { Chewy.massacre }
-
-  before do
-    stub_model(:city)
-    stub_model(:country)
-  end
-
-  context 'multiple types' do
-    let(:cities) { 6.times.map { |i| City.create!(rating: i) } }
-    let(:countries) { 6.times.map { |i| Country.create!(rating: i) } }
-
-    before do
-      stub_index(:places) do
-        define_type City do
-          field :rating, type: 'integer', value: ->(o){ o.rating }
-        end
-
-        define_type Country do
-          field :rating, type: 'integer', value: ->(o){ o.rating }
-        end
-      end
-    end
-
-    before { PlacesIndex.import!(cities: cities, countries: countries) }
-
-    describe '#load' do
-      specify { expect(PlacesIndex.order(:rating).limit(6).load.total_count).to eq(12) }
-      specify { expect(PlacesIndex.order(:rating).limit(6).load).to match_array(cities.first(3) + countries.first(3)) }
-
-      context 'mongoid', :mongoid do
-        specify { expect(PlacesIndex.order(:rating).limit(6).load(city: { scope: ->{ where(:rating.lt => 2) } }))
-          .to match_array(cities.first(2) + countries.first(3) + [nil]) }
-        specify { expect(PlacesIndex.limit(6).load(city: { scope: ->{ where(:rating.lt => 2) } }).order(:rating))
-          .to match_array(cities.first(2) + countries.first(3) + [nil]) }
-        specify { expect(PlacesIndex.order(:rating).limit(6).load(scope: ->{ where(:rating.lt => 2) }))
-          .to match_array(cities.first(2) + countries.first(2) + [nil] * 2) }
-        specify { expect(PlacesIndex.order(:rating).limit(6).load(city: { scope: City.where(:rating.lt => 2) }))
-          .to match_array(cities.first(2) + countries.first(3) + [nil]) }
-      end
-
-      context 'active record', :active_record do
-        specify { expect(PlacesIndex.order(:rating).limit(6).load(city: { scope: ->{ where('rating < 2') } }))
-          .to match_array(cities.first(2) + countries.first(3) + [nil]) }
-        specify { expect(PlacesIndex.limit(6).load(city: { scope: ->{ where('rating < 2') } }).order(:rating))
-          .to match_array(cities.first(2) + countries.first(3) + [nil]) }
-        specify { expect(PlacesIndex.order(:rating).limit(6).load(scope: ->{ where('rating < 2') }))
-          .to match_array(cities.first(2) + countries.first(2) + [nil] * 2) }
-        specify { expect(PlacesIndex.order(:rating).limit(6).load(city: { scope: City.where('rating < 2') }))
-          .to match_array(cities.first(2) + countries.first(3) + [nil]) }
-      end
-    end
-
-    describe '#preload' do
-      context 'mongoid', :mongoid do
-        specify { expect(PlacesIndex.order(:rating).limit(6).preload(scope: ->{ where(:rating.lt => 2) })
-          .map(&:_object)).to match_array(cities.first(2) + countries.first(2) + [nil] * 2) }
-        specify { expect(PlacesIndex.limit(6).preload(scope: ->{ where(:rating.lt => 2) }).order(:rating)
-          .map(&:_object)).to match_array(cities.first(2) + countries.first(2) + [nil] * 2) }
-
-        specify { expect(PlacesIndex.order(:rating).limit(6).preload(only: :city, scope: ->{ where(:rating.lt => 2) })
-          .map(&:_object)).to match_array(cities.first(2) + [nil] * 4) }
-        specify { expect(PlacesIndex.order(:rating).limit(6).preload(except: [:city], scope: ->{ where(:rating.lt => 2) })
-          .map(&:_object)).to match_array(countries.first(2) + [nil] * 4) }
-        specify { expect(PlacesIndex.order(:rating).limit(6).preload(only: [:city], except: :city, scope: ->{ where(:rating.lt => 2) })
-          .map(&:_object)).to match_array([nil] * 6) }
-      end
-
-      context 'active record', :active_record do
-        specify { expect(PlacesIndex.order(:rating).limit(6).preload(scope: ->{ where('rating < 2') })
-          .map(&:_object)).to match_array(cities.first(2) + countries.first(2) + [nil] * 2) }
-        specify { expect(PlacesIndex.limit(6).preload(scope: ->{ where('rating < 2') }).order(:rating)
-          .map(&:_object)).to match_array(cities.first(2) + countries.first(2) + [nil] * 2) }
-
-        specify { expect(PlacesIndex.order(:rating).limit(6).preload(only: :city, scope: ->{ where('rating < 2') })
-          .map(&:_object)).to match_array(cities.first(2) + [nil] * 4) }
-        specify { expect(PlacesIndex.order(:rating).limit(6).preload(except: [:city], scope: ->{ where('rating < 2') })
-          .map(&:_object)).to match_array(countries.first(2) + [nil] * 4) }
-        specify { expect(PlacesIndex.order(:rating).limit(6).preload(only: [:city], except: :city, scope: ->{ where('rating < 2') })
-          .map(&:_object)).to match_array([nil] * 6) }
-      end
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Query::Nodes::And do
-  describe '#__render__' do
-    def render &block
-      Chewy::Query::Filters.new(&block).__render__
-    end
-
-    specify { expect(render { name? & (email == 'email') }).to eq({
-      and: [{exists: {field: 'name'}}, {term: {'email' => 'email'}}]
-    }) }
-    specify { expect(render { ~(name? & (email == 'email')) }).to eq({
-      and: {filters: [{exists: {field: 'name'}}, {term: {'email' => 'email'}}], _cache: true}
-    }) }
-  end
-end

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

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Query::Nodes::Bool do
-  describe '#__render__' do
-    def render &block
-      Chewy::Query::Filters.new(&block).__render__
-    end
-
-    specify { expect(render { must(name == 'name', email == 'email') }).to eq({
-      bool: {must: [{term: {'name' => 'name'}}, {term: {'email' => 'email'}}]
-    } }) }
-    specify { expect(render { must(name == 'name').must_not(email == 'email') }).to eq({
-      bool: {must: [{term: {'name' => 'name'}}], must_not: [{term: {'email' => 'email'}}]
-    } }) }
-    specify { expect(render { must(name == 'name').should(email == 'email') }).to eq({
-      bool: {must: [{term: {'name' => 'name'}}], should: [{ term: {'email' => 'email'}}]
-    } }) }
-    specify { expect(render { ~must(name == 'name').should(email == 'email') }).to eq({
-      bool: {must: [{term: {'name' => 'name'}}], should: [{ term: {'email' => 'email'}}], _cache: true
-    } }) }
-  end
-end

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

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Query::Nodes::Equal do
-  describe '#__render__' do
-    def render &block
-      Chewy::Query::Filters.new(&block).__render__
-    end
-
-    specify { expect(render { name == 'name' }).to eq({term: {'name' => 'name'}}) }
-    specify { expect(render { name != 'name' }).to eq({not: {term: {'name' => 'name'}}}) }
-    specify { expect(render { name == ['name1', 'name2'] }).to eq({terms: {'name' => ['name1', 'name2']}}) }
-    specify { expect(render { name != ['name1', 'name2'] }).to eq({not: {terms: {'name' => ['name1', 'name2']}}}) }
-
-    specify { expect(render { name(:bool) == 'name' }).to eq({term: {'name' => 'name'}}) }
-    specify { expect(render { name(:borogoves) == ['name1', 'name2'] }).to eq({terms: {'name' => ['name1', 'name2']}}) }
-
-    specify { expect(render { name(:|) == ['name1', 'name2'] }).to eq({terms: {'name' => ['name1', 'name2'], execution: :or}}) }
-    specify { expect(render { name(:or) == ['name1', 'name2'] }).to eq({terms: {'name' => ['name1', 'name2'], execution: :or}}) }
-    specify { expect(render { name(:&) == ['name1', 'name2'] }).to eq({terms: {'name' => ['name1', 'name2'], execution: :and}}) }
-    specify { expect(render { name(:and) == ['name1', 'name2'] }).to eq({terms: {'name' => ['name1', 'name2'], execution: :and}}) }
-    specify { expect(render { name(:b) == ['name1', 'name2'] }).to eq({terms: {'name' => ['name1', 'name2'], execution: :bool}}) }
-    specify { expect(render { name(:bool) == ['name1', 'name2'] }).to eq({terms: {'name' => ['name1', 'name2'], execution: :bool}}) }
-    specify { expect(render { name(:f) == ['name1', 'name2'] }).to eq({terms: {'name' => ['name1', 'name2'], execution: :fielddata}}) }
-    specify { expect(render { name(:fielddata) == ['name1', 'name2'] }).to eq({terms: {'name' => ['name1', 'name2'], execution: :fielddata}}) }
-
-    specify { expect(render { ~name == 'name' }).to eq({term: {'name' => 'name', _cache: true}}) }
-    specify { expect(render { ~(name == 'name') }).to eq({term: {'name' => 'name', _cache: true}}) }
-    specify { expect(render { ~name != 'name' }).to eq({not: {term: {'name' => 'name', _cache: true}}}) }
-    specify { expect(render { ~name(:|) == ['name1', 'name2'] }).to eq({terms: {'name' => ['name1', 'name2'], execution: :or, _cache: true}}) }
-    specify { expect(render { ~name != ['name1', 'name2'] }).to eq({not: {terms: {'name' => ['name1', 'name2'], _cache: true}}}) }
-  end
-end

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

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Query::Nodes::Exists do
-  describe '#__render__' do
-    def render &block
-      Chewy::Query::Filters.new(&block).__render__
-    end
-
-    specify { expect(render { name? }).to eq({exists: {field: 'name'}}) }
-
-    specify { expect(render { !!name? }).to eq({exists: {field: 'name'}}) }
-    specify { expect(render { !!name }).to eq({exists: {field: 'name'}}) }
-    specify { expect(render { name != nil }).to eq({exists: {field: 'name'}}) }
-    specify { expect(render { !(name == nil) }).to eq({exists: {field: 'name'}}) }
-
-    specify { expect(render { ~name? }).to eq({exists: {field: 'name'}}) }
-  end
-end

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

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

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

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Query::Nodes::HasParent do
-  describe '#__render__' do
-    def render &block
-      Chewy::Query::Filters.new(&block).__render__
-    end
-
-    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 { 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

@@ -1,11 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Query::Nodes::MatchAll do
-  describe '#__render__' do
-    def render &block
-      Chewy::Query::Filters.new(&block).__render__
-    end
-
-    specify { expect(render { match_all }).to eq({match_all: {}}) }
-  end
-end

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

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Query::Nodes::Missing do
-  describe '#__render__' do
-    def render &block
-      Chewy::Query::Filters.new(&block).__render__
-    end
-
-    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 { expect(render { ~!name }).to eq({missing: {field: 'name', existence: true, null_value: false}}) }
-  end
-end

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

@@ -1,16 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Query::Nodes::Not do
-  describe '#__render__' do
-    def render &block
-      Chewy::Query::Filters.new(&block).__render__
-    end
-
-    specify { expect(render { !(email == 'email') }).to eq({
-      not: {term: {'email' => 'email'}}
-    }) }
-    specify { expect(render { ~!(email == 'email') }).to eq({
-      not: {filter: {term: {'email' => 'email'}}, _cache: true}
-    }) }
-  end
-end

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

@@ -1,16 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Query::Nodes::Or do
-  describe '#__render__' do
-    def render &block
-      Chewy::Query::Filters.new(&block).__render__
-    end
-
-    specify { expect(render { name? | (email == 'email') }).to eq({
-      or: [{exists: {field: 'name'}}, {term: {'email' => 'email'}}]
-    }) }
-    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

@@ -1,16 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Query::Nodes::Prefix do
-  describe '#__render__' do
-    def render &block
-      Chewy::Query::Filters.new(&block).__render__
-    end
-
-    specify { expect(render { name =~ 'nam' }).to eq({prefix: {'name' => 'nam'}}) }
-    specify { expect(render { name !~ 'nam' }).to eq({not: {prefix: {'name' => 'nam'}}}) }
-
-    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

@@ -1,12 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Query::Nodes::Query do
-  describe '#__render__' do
-    def render &block
-      Chewy::Query::Filters.new(&block).__render__
-    end
-
-    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

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Query::Nodes::Range do
-  describe '#__render__' do
-    def render &block
-      Chewy::Query::Filters.new(&block).__render__
-    end
-
-    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 { 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 { 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 { 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 { 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

@@ -1,11 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Query::Nodes::Raw do
-  describe '#__render__' do
-    def render &block
-      Chewy::Query::Filters.new(&block).__render__
-    end
-
-    specify { expect(render { r(term: {name: 'name'}) }).to eq({term: {name: 'name'}}) }
-  end
-end

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

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Query::Nodes::Regexp do
-  describe '#__render__' do
-    def render &block
-      Chewy::Query::Filters.new(&block).__render__
-    end
-
-    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 { 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 { 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 { 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

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Query::Nodes::Script do
-  describe '#__render__' do
-    def render &block
-      Chewy::Query::Filters.new(&block).__render__
-    end
-
-    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 { 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,57 +0,0 @@
-require 'spec_helper'
-
-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
-
-    let(:search) { ProductsIndex.order(:age) }
-
-    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! } }
-
-      before { ProductsIndex::Product.import!(data.map { |h| double(h) }) }
-      before { allow(::Kaminari.config).to receive_messages(default_per_page: 3) }
-
-      describe '#per, #page' do
-        specify { expect(search.map { |e| e.attributes.except('_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 { 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.filter(numeric_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
-    end
-  end
-end

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

@@ -1,60 +0,0 @@
-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,36 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Query::Pagination 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_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! } }
-
-    before { ProductsIndex::Product.import!(data.map { |h| double(h) }) }
-
-    describe '#total_count' do
-      specify { expect(search.total_count).to eq(10) }
-      specify { expect(search.limit(5).total_count).to eq(10) }
-      specify { expect(search.filter(range: {age: {gt: 20}}).limit(3).total_count).to eq(8) }
-    end
-
-    describe '#load' do
-      specify { expect(search.load.total_count).to eq(10) }
-      specify { expect(search.limit(5).load.total_count).to eq(10) }
-    end
-  end
-
-end