chewy 5.0.0 → 7.0.1

data/spec/chewy/query/filters_spec.rb

@@ -1,201 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Query::Filters do
-  def Bool(options) # rubocop:disable Naming/MethodName
-    Chewy::Query::Nodes::Bool.new.tap do |bool|
-      bool.must(*options[:must]) if options[:must].present?
-      bool.must_not(*options[:must_not]) if options[:must_not].present?
-      bool.should(*options[:should]) if options[:should].present?
-    end
-  end
-
-  %w[field group and or not raw exists missing prefix regexp range equal query script].each do |method|
-    define_method method.camelize do |*args|
-      "Chewy::Query::Nodes::#{method.camelize}".constantize.new(*args)
-    end
-  end
-
-  def query(&block)
-    Chewy::Query::Filters.new(&block).__result__
-  end
-
-  context 'outer scope' do
-    let(:email) { 'email' }
-    specify { expect(query { email }).to be_eql Field(:email) }
-    specify { expect(query { o { email } }).to eq('email') }
-  end
-
-  context 'field' do
-    let(:email) { 'email' }
-    specify { expect(query { f(:email) }).to be_eql Field(:email) }
-    specify { expect(query { f { :email } }).to be_eql Field(:email) }
-    specify { expect(query { f { email } }).to be_eql Field(:email) }
-    specify { expect(query { email }).to be_eql Field(:email) }
-    specify { expect(query { emails.first }).to be_eql Field('emails.first') }
-    specify { expect(query { emails.first.second }).to be_eql Field('emails.first.second') }
-  end
-
-  context 'term' do
-    specify { expect(query { email == 'email' }).to be_eql Equal(:email, 'email') }
-    specify { expect(query { name != 'name' }).to be_eql Not(Equal(:name, 'name')) }
-    specify { expect(query { email == %w[email1 email2] }).to be_eql Equal(:email, %w[email1 email2]) }
-    specify { expect(query { email != %w[email1 email2] }).to be_eql Not(Equal(:email, %w[email1 email2])) }
-    specify do
-      expect(query { email(execution: :bool) == %w[email1 email2] })
-        .to be_eql Equal(:email, %w[email1 email2], execution: :bool)
-    end
-    specify do
-      expect(query { email(:bool) == %w[email1 email2] })
-        .to be_eql Equal(:email, %w[email1 email2], execution: :bool)
-    end
-    specify do
-      expect(query { email(:b) == %w[email1 email2] })
-        .to be_eql Equal(:email, %w[email1 email2], execution: :bool)
-    end
-  end
-
-  context 'bool' do
-    specify { query { must(email == 'email') }.should be_eql Bool(must: [Equal(:email, 'email')]) }
-    specify { query { must_not(email == 'email') }.should be_eql Bool(must_not: [Equal(:email, 'email')]) }
-    specify { query { should(email == 'email') }.should be_eql Bool(should: [Equal(:email, 'email')]) }
-    specify do
-      query do
-        must(email == 'email').should(address != 'address', age == 42)
-          .must_not(sex == 'm').must(name == 'name')
-      end.should be_eql Bool(
-        must: [Equal(:email, 'email'), Equal(:name, 'name')],
-        must_not: [Equal(:sex, 'm')],
-        should: [Not(Equal(:address, 'address')), Equal(:age, 42)]
-      )
-    end
-  end
-
-  context 'exists' do
-    specify { expect(query { email? }).to be_eql Exists(:email) }
-    specify { expect(query { !!email? }).to be_eql Exists(:email) }
-    specify { expect(query { emails.first? }).to be_eql Exists('emails.first') }
-    specify { expect(query { !!emails.first? }).to be_eql Exists('emails.first') }
-    specify { expect(query { emails != nil }).to be_eql Exists('emails') } # rubocop:disable Style/NonNilCheck
-    specify { expect(query { emails.first != nil }).to be_eql Exists('emails.first') } # rubocop:disable Style/NonNilCheck
-    specify { expect(query { !emails.nil? }).to be_eql Exists('emails') }
-    specify { expect(query { !emails.first.nil? }).to be_eql Exists('emails.first') }
-  end
-
-  context 'missing' do
-    specify { expect(query { !email }).to be_eql Missing(:email) }
-    specify { expect(query { !email? }).to be_eql Missing(:email, null_value: true) }
-    specify { expect(query { !emails.first }).to be_eql Missing('emails.first') }
-    specify { expect(query { !emails.first? }).to be_eql Missing('emails.first', null_value: true) }
-    specify { expect(query { emails == nil }).to be_eql Missing('emails', existence: false, null_value: true) } # rubocop:disable Style/NilComparison
-    specify { expect(query { emails.first == nil }).to be_eql Missing('emails.first', existence: false, null_value: true) } # rubocop:disable Style/NilComparison
-    specify { expect(query { emails.nil? }).to be_eql Missing('emails', existence: false, null_value: true) }
-    specify { expect(query { emails.first.nil? }).to be_eql Missing('emails.first', existence: false, null_value: true) }
-  end
-
-  context 'range' do
-    specify { expect(query { age > 42 }).to be_eql Range(:age, gt: 42) }
-    specify { expect(query { age >= 42 }).to be_eql Range(:age, gt: 42, left_closed: true) }
-    specify { expect(query { age < 42 }).to be_eql Range(:age, lt: 42) }
-    specify { expect(query { age <= 42 }).to be_eql Range(:age, lt: 42, right_closed: true) }
-
-    specify { expect(query { age == (30..42) }).to be_eql Range(:age, gt: 30, lt: 42) }
-    specify { expect(query { age == [30..42] }).to be_eql Range(:age, gt: 30, lt: 42, left_closed: true, right_closed: true) }
-    specify { expect(query { (age > 30) & (age < 42) }).to be_eql Range(:age, gt: 30, lt: 42) }
-    specify { expect(query { (age > 30) & (age <= 42) }).to be_eql Range(:age, gt: 30, lt: 42, right_closed: true) }
-    specify { expect(query { (age >= 30) & (age < 42) }).to be_eql Range(:age, gt: 30, lt: 42, left_closed: true) }
-    specify { expect(query { (age >= 30) & (age <= 42) }).to be_eql Range(:age, gt: 30, lt: 42, right_closed: true, left_closed: true) }
-    specify { expect(query { (age > 30) | (age < 42) }).to be_eql Or(Range(:age, gt: 30), Range(:age, lt: 42)) }
-  end
-
-  context 'prefix' do
-    specify { expect(query { name =~ 'nam' }).to be_eql Prefix(:name, 'nam') }
-    specify { expect(query { name !~ 'nam' }).to be_eql Not(Prefix(:name, 'nam')) }
-  end
-
-  context 'regexp' do
-    specify { expect(query { name =~ /name/ }).to be_eql Regexp(:name, 'name') }
-    specify { expect(query { name == /name/ }).to be_eql Regexp(:name, 'name') }
-    specify { expect(query { name !~ /name/ }).to be_eql Not(Regexp(:name, 'name')) }
-    specify { expect(query { name != /name/ }).to be_eql Not(Regexp(:name, 'name')) }
-    specify { expect(query { name(:anystring, :intersection) =~ /name/ }).to be_eql Regexp(:name, 'name', flags: %w[anystring intersection]) }
-  end
-
-  context 'query' do
-    let(:some_query) { 'some query' }
-    specify { expect(query { q('some query') }).to be_eql Query('some query') }
-    specify { expect(query { q { 'some query' } }).to be_eql Query('some query') }
-    specify { expect(query { q { some_query } }).to be_eql Query('some query') }
-  end
-
-  context 'raw' do
-    let(:raw_query) { {term: {name: 'name'}} }
-    specify { expect(query { r(term: {name: 'name'}) }).to be_eql Raw(term: {name: 'name'}) }
-    specify { expect(query { r { {term: {name: 'name'}} } }).to be_eql Raw(term: {name: 'name'}) }
-    specify { expect(query { r { raw_query } }).to be_eql Raw(term: {name: 'name'}) }
-  end
-
-  context 'script' do
-    let(:some_script) { 'some script' }
-    specify { expect(query { s('some script') }).to be_eql Script('some script') }
-    specify { expect(query { s('some script', param1: 42) }).to be_eql Script('some script', param1: 42) }
-    specify { expect(query { s { 'some script' } }).to be_eql Script('some script') }
-    specify { expect(query { s(param1: 42) { some_script } }).to be_eql Script('some script', param1: 42) }
-  end
-
-  context 'and or not' do
-    specify do
-      expect(query { (email == 'email') & (name == 'name') })
-        .to be_eql And(Equal(:email, 'email'), Equal(:name, 'name'))
-    end
-    specify do
-      expect(query { (email == 'email') | (name == 'name') })
-        .to be_eql Or(Equal(:email, 'email'), Equal(:name, 'name'))
-    end
-    specify { expect(query { email != 'email' }).to be_eql Not(Equal(:email, 'email')) }
-
-    specify do
-      expect(query { (email == 'email') & (name == 'name') | (address != 'address') })
-        .to be_eql Or(
-          And(
-            Equal(:email, 'email'),
-            Equal(:name, 'name')
-          ),
-          Not(Equal(:address, 'address'))
-        )
-    end
-    specify do
-      expect(query { (email == 'email') & ((name == 'name') | (address != 'address')) })
-        .to be_eql And(
-          Equal(:email, 'email'),
-          Or(
-            Equal(:name, 'name'),
-            Not(Equal(:address, 'address'))
-          )
-        )
-    end
-    specify do
-      expect(query { (email == 'email') & ((name == 'name') & (address != 'address')) })
-        .to be_eql And(
-          Equal(:email, 'email'),
-          Equal(:name, 'name'),
-          Not(Equal(:address, 'address'))
-        )
-    end
-    specify do
-      expect(query { ((email == 'email') | (name == 'name')) | (address != 'address') })
-        .to be_eql Or(
-          Equal(:email, 'email'),
-          Equal(:name, 'name'),
-          Not(Equal(:address, 'address'))
-        )
-    end
-    specify do
-      expect(query { !((email == 'email') | (name == 'name')) })
-        .to be_eql Not(Or(Equal(:email, 'email'), Equal(:name, 'name')))
-    end
-    specify do
-      expect(query { !!((email == 'email') | (name == 'name')) })
-        .to be_eql Or(Equal(:email, 'email'), Equal(:name, 'name'))
-    end
-  end
-end

data/spec/chewy/query/loading_spec.rb

@@ -1,124 +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) { Array.new(6) { |i| City.create!(rating: i) } }
-    let(:countries) { Array.new(6) { |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
-
-    let(:subject) { Chewy::Query.new(PlacesIndex) }
-
-    before { PlacesIndex.import!(cities: cities, countries: countries) }
-
-    describe '#load' do
-      specify { expect(subject.order(:rating).limit(6).load.total_count).to eq(12) }
-      specify { expect(subject.order(:rating).limit(6).load).to match_array(cities.first(3) + countries.first(3)) }
-
-      context 'mongoid', :mongoid do
-        specify do
-          expect(subject.order(:rating).limit(6).load(city: {scope: -> { where(:rating.lt => 2) }}))
-            .to match_array(cities.first(2) + countries.first(3) + [nil])
-        end
-        specify do
-          expect(subject.limit(6).load(city: {scope: -> { where(:rating.lt => 2) }}).order(:rating))
-            .to match_array(cities.first(2) + countries.first(3) + [nil])
-        end
-        specify do
-          expect(subject.order(:rating).limit(6).load(scope: -> { where(:rating.lt => 2) }))
-            .to match_array(cities.first(2) + countries.first(2) + [nil] * 2)
-        end
-        specify do
-          expect(subject.order(:rating).limit(6).load(city: {scope: City.where(:rating.lt => 2)}))
-            .to match_array(cities.first(2) + countries.first(3) + [nil])
-        end
-      end
-
-      context 'active record', :active_record do
-        specify do
-          expect(subject.order(:rating).limit(6).load(city: {scope: -> { where('rating < 2') }}))
-            .to match_array(cities.first(2) + countries.first(3) + [nil])
-        end
-        specify do
-          expect(subject.limit(6).load(city: {scope: -> { where('rating < 2') }}).order(:rating))
-            .to match_array(cities.first(2) + countries.first(3) + [nil])
-        end
-        specify do
-          expect(subject.order(:rating).limit(6).load(scope: -> { where('rating < 2') }))
-            .to match_array(cities.first(2) + countries.first(2) + [nil] * 2)
-        end
-        specify do
-          expect(subject.order(:rating).limit(6).load(city: {scope: City.where('rating < 2')}))
-            .to match_array(cities.first(2) + countries.first(3) + [nil])
-        end
-      end
-    end
-
-    describe '#preload' do
-      context 'mongoid', :mongoid do
-        specify do
-          expect(subject.order(:rating).limit(6).preload(scope: -> { where(:rating.lt => 2) })
-          .map(&:_object)).to match_array(cities.first(2) + countries.first(2) + [nil] * 2)
-        end
-        specify do
-          expect(subject.limit(6).preload(scope: -> { where(:rating.lt => 2) }).order(:rating)
-          .map(&:_object)).to match_array(cities.first(2) + countries.first(2) + [nil] * 2)
-        end
-
-        specify do
-          expect(subject.order(:rating).limit(6).preload(only: :city, scope: -> { where(:rating.lt => 2) })
-          .map(&:_object)).to match_array(cities.first(2) + [nil] * 4)
-        end
-        specify do
-          expect(subject.order(:rating).limit(6).preload(except: [:city], scope: -> { where(:rating.lt => 2) })
-          .map(&:_object)).to match_array(countries.first(2) + [nil] * 4)
-        end
-        specify do
-          expect(subject.order(:rating).limit(6).preload(only: [:city], except: :city, scope: -> { where(:rating.lt => 2) })
-          .map(&:_object)).to match_array([nil] * 6)
-        end
-      end
-
-      context 'active record', :active_record do
-        specify do
-          expect(subject.order(:rating).limit(6).preload(scope: -> { where('rating < 2') })
-          .map(&:_object)).to match_array(cities.first(2) + countries.first(2) + [nil] * 2)
-        end
-        specify do
-          expect(subject.limit(6).preload(scope: -> { where('rating < 2') }).order(:rating)
-          .map(&:_object)).to match_array(cities.first(2) + countries.first(2) + [nil] * 2)
-        end
-
-        specify do
-          expect(subject.order(:rating).limit(6).preload(only: :city, scope: -> { where('rating < 2') })
-          .map(&:_object)).to match_array(cities.first(2) + [nil] * 4)
-        end
-        specify do
-          expect(subject.order(:rating).limit(6).preload(except: [:city], scope: -> { where('rating < 2') })
-          .map(&:_object)).to match_array(countries.first(2) + [nil] * 4)
-        end
-        specify do
-          expect(subject.order(:rating).limit(6).preload(only: [:city], except: :city, scope: -> { where('rating < 2') })
-          .map(&:_object)).to match_array([nil] * 6)
-        end
-      end
-    end
-  end
-end

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

@@ -1,12 +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,14 +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 == %w[name1 name2] }).to eq(terms: {'name' => %w[name1 name2]}) }
-    specify { expect(render { name != %w[name1 name2] }).to eq(not: {terms: {'name' => %w[name1 name2]}}) }
-
-    specify { expect(render { name(:bool) == 'name' }).to eq(term: {'name' => 'name'}) }
-    specify { expect(render { name(:borogoves) == %w[name1 name2] }).to eq(terms: {'name' => %w[name1 name2]}) }
-
-    specify { expect(render { name(:|) == %w[name1 name2] }).to eq(terms: {'name' => %w[name1 name2], execution: :or}) }
-    specify { expect(render { name(:or) == %w[name1 name2] }).to eq(terms: {'name' => %w[name1 name2], execution: :or}) }
-    specify { expect(render { name(:&) == %w[name1 name2] }).to eq(terms: {'name' => %w[name1 name2], execution: :and}) }
-    specify { expect(render { name(:and) == %w[name1 name2] }).to eq(terms: {'name' => %w[name1 name2], execution: :and}) }
-    specify { expect(render { name(:b) == %w[name1 name2] }).to eq(terms: {'name' => %w[name1 name2], execution: :bool}) }
-    specify { expect(render { name(:bool) == %w[name1 name2] }).to eq(terms: {'name' => %w[name1 name2], execution: :bool}) }
-    specify { expect(render { name(:f) == %w[name1 name2] }).to eq(terms: {'name' => %w[name1 name2], execution: :fielddata}) }
-    specify { expect(render { name(:fielddata) == %w[name1 name2] }).to eq(terms: {'name' => %w[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(:|) == %w[name1 name2] }).to eq(terms: {'name' => %w[name1 name2], execution: :or, _cache: true}) }
-    specify { expect(render { ~name != %w[name1 name2] }).to eq(not: {terms: {'name' => %w[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'}) } # rubocop:disable Style/NonNilCheck
-    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,59 +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 do
-      expect(render { has_child('child').filter(term: {name: 'name'}) })
-        .to eq(has_child: {type: 'child', filter: {term: {name: 'name'}}})
-    end
-    specify do
-      expect(render { has_child('child').filter { name == 'name' } })
-        .to eq(has_child: {type: 'child', filter: {term: {'name' => 'name'}}})
-    end
-    specify do
-      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}}]}})
-    end
-    specify do
-      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}}]}})
-    end
-
-    specify do
-      expect(render { has_child('child').query(match: {name: 'name'}) })
-        .to eq(has_child: {type: 'child', query: {match: {name: 'name'}}})
-    end
-    specify do
-      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'}}]}}})
-    end
-    specify do
-      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'}}]}}})
-    end
-
-    specify do
-      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'}}}}})
-    end
-    specify do
-      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}}]}}}})
-    end
-
-    context do
-      let(:name) { 'Name' }
-
-      specify do
-        expect(render { has_child('child').filter { name == o { name } } })
-          .to eq(has_child: {type: 'child', filter: {term: {'name' => 'Name'}}})
-      end
-    end
-  end
-end