mongoid 7.1.11 → 7.2.0

data/spec/integration/matcher_operator_data/size.yml

@@ -0,0 +1,174 @@
+- name: correct size
+  document:
+    products: [1, 2, 3]
+  query:
+    products:
+      $size: 3
+  matches: true
+
+- name: incorrect size
+  document:
+    products: [1, 2, 3]
+  query:
+    products:
+      $size: 2
+  matches: false
+
+- name: empty array - correct size
+  document:
+    products: []
+  query:
+    products:
+      $size: 0
+  matches: true
+
+- name: empty array - incorrect size
+  document:
+    products: []
+  query:
+    products:
+      $size: 1
+  matches: false
+
+- name: condition is an array
+  document:
+    products: [1, 2, 3]
+  query:
+    products:
+      - $size: 3
+  matches: false
+
+- name: field value is a scalar
+  document:
+    hello: world
+  query:
+    hello:
+      $size: 5
+  matches: false
+
+- name: field value is a hash
+  document:
+    hello:
+      foo: bar
+  query:
+    hello:
+      $size: 1
+  matches: false
+
+- name: nil argument
+  document:
+    position: ceo
+  query:
+    position:
+      $size: ~
+  error: true
+
+- name: empty array argument
+  document:
+    position: ceo
+  query:
+    position:
+      $size: []
+  error: true
+
+- name: empty hash argument
+  document:
+    position: ceo
+  query:
+    position:
+      $size: {}
+  error: true
+
+- name: string argument
+  document:
+    position: ceo
+  query:
+    position:
+      $size: foo
+  error: true
+  min_server_version: 3.4
+
+- name: floating point argument
+  document:
+    position: ceo
+  query:
+    position:
+      $size: 2.5
+  error: true
+  min_server_version: 3.4
+
+- name: negative integer argument
+  document:
+    position: ceo
+  query:
+    position:
+      $size: -2
+  error: true
+  min_server_version: 3.4
+
+- name: empty array field value
+  document:
+    position: []
+  query:
+    position:
+      $size: 1
+  matches: false
+
+- name: empty hash field value
+  document:
+    position: {}
+  query:
+    position:
+      $size: 1
+  matches: false
+
+- name: numeric field value
+  document:
+    position: 42
+  query:
+    position:
+      $size: 1
+  matches: false
+
+- name: string field value
+  document:
+    position: foo
+  query:
+    position:
+      $size: 1
+  matches: false
+
+- name: true field value
+  document:
+    position: true
+  query:
+    position:
+      $size: 0
+  matches: false
+
+- name: false field value
+  document:
+    position: false
+  query:
+    position:
+      $size: 0
+  matches: false
+
+- name: null field value
+  document:
+    position: ~
+  query:
+    position:
+      $size: 0
+  matches: false
+
+- name: range
+  document:
+    name: 42
+  query:
+    name:
+      $size: !ruby/range
+        begin: 1
+        end: 2
+        excl: false
+  error: true

data/spec/integration/matcher_operator_spec.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+
+def mop_error?(spec, kind)
+  unless %w(matcher driver dsl).include?(kind)
+    raise ArgumentError, "Bogus kind: #{kind}"
+  end
+
+  spec['error'] == true || spec['error'] == kind ||
+    spec['error'].is_a?(Array) && spec['error'].include?(kind)
+end
+
+describe 'Matcher operators' do
+  Dir[File.join(File.dirname(__FILE__), 'matcher_operator_data', '*.yml')].sort.each do |path|
+    context File.basename(path) do
+      specs = YAML.load(File.read(path))
+
+      specs.each do |spec|
+        context spec['name'] do
+
+          if spec['pending']
+            before do
+              # Cannot use `pending` here because some of the queries may work
+              # as specified (e.g. when Mongoid and server behavior differ).
+              skip spec['pending'].to_s
+            end
+          end
+
+          if spec['min_server_version']
+            min_server_version spec['min_server_version'].to_s
+          end
+
+          let(:query) { spec.fetch('query') }
+          let(:result) { spec.fetch('matches') }
+
+          context 'embedded matching' do
+            let(:document) { Mop.new(spec.fetch('document')) }
+
+            if mop_error?(spec, 'matcher')
+              it 'produces an error' do
+                lambda do
+                  document._matches?(query)
+                end.should raise_error(Mongoid::Errors::InvalidQuery)
+              end
+            else
+              it 'produces the correct result' do
+                document._matches?(query).should be result
+              end
+            end
+          end
+
+          context 'server query' do
+            let!(:document) { Mop.create(spec.fetch('document')) }
+
+            context 'via driver' do
+              if mop_error?(spec, 'driver')
+                it 'produces an error' do
+                  begin
+                    Mop.collection.find(query).any?
+                  rescue Mongo::Error::OperationFailure
+                  rescue Mongo::Error::InvalidDocument
+                  rescue BSON::Error::UnserializableClass
+                  else
+                    fail "Expected an exception to be raised"
+                  end
+                end
+              else
+                it 'produces the correct result' do
+                  Mop.collection.find(query).any?.should be result
+                end
+              end
+            end
+
+            context 'via Mongoid DSL' do
+              if mop_error?(spec, 'dsl')
+                it 'produces an error' do
+                  begin
+                    Mop.where(query).any?
+                  rescue Mongo::Error::OperationFailure
+                  rescue BSON::Error::UnserializableClass
+                  rescue Mongoid::Errors::InvalidQuery
+                  rescue Mongoid::Errors::CriteriaArgumentRequired
+                  else
+                    fail "Expected the query to raise an error"
+                  end
+                end
+              else
+                it 'produces the correct result' do
+                  Mop.where(query).any?.should be result
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/integration/matcher_spec.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe 'Matcher operators' do
+  let(:result) do
+    document._matches?(query)
+  end
+
+  shared_examples 'is true' do
+    it 'is true' do
+      result.should be true
+    end
+  end
+
+  shared_examples 'is false' do
+    it 'is false 'do
+      result.should be false
+    end
+  end
+
+  context 'when querying nested document' do
+    context 'embeds_one' do
+      let(:document) do
+        Canvas.new(
+          writer: Writer.new(speed: 3),
+        )
+      end
+
+      context 'implicit $eq' do
+        context 'matches' do
+          let(:query) do
+            {'writer.speed' => 3}
+          end
+
+          it_behaves_like 'is true'
+        end
+
+        context 'does not match' do
+          let(:query) do
+            {'speed' => 3}
+          end
+
+          it_behaves_like 'is false'
+        end
+      end
+
+      context 'field operator' do
+        # Test string and symbol operators
+        ['$gt', :$gt].each do |op|
+          context op.inspect do
+            context 'matches' do
+              let(:query) do
+                {'writer.speed' => {op => 2}}
+              end
+
+              it_behaves_like 'is true'
+            end
+
+            context 'does not match' do
+              let(:query) do
+                {'writer.speed' => {op => 3}}
+              end
+
+              it_behaves_like 'is false'
+            end
+          end
+        end
+      end
+
+      context 'hash query' do
+        context 'scalar field in embedded document' do
+          context 'matches' do
+            let(:query) do
+              {writer: {speed: 3}}
+            end
+
+            it_behaves_like 'is true'
+          end
+
+          context 'does not match' do
+            let(:query) do
+              {writer: {slow: 3}}
+            end
+
+            it_behaves_like 'is false'
+          end
+        end
+
+        context 'hash field' do
+          let(:document) do
+            Bar.new(
+              writer: {speed: 3},
+            )
+          end
+
+          context 'matches' do
+            let(:query) do
+              {writer: {speed: 3}}
+            end
+
+            it_behaves_like 'is true'
+          end
+
+          context 'does not match' do
+            let(:query) do
+              {writer: {slow: 3}}
+            end
+
+            it_behaves_like 'is false'
+          end
+        end
+      end
+    end
+
+    context 'embeds_many' do
+      let(:document) do
+        Survey.new(
+          questions: [Question.new(
+            answers: [
+              Answer.new(position: 3),
+              Answer.new(position: 4),
+            ],
+          )],
+        )
+      end
+
+      context 'implicit $eq' do
+        context 'matches' do
+          let(:query) do
+            {'questions.answers.position' => 3}
+          end
+
+          it_behaves_like 'is true'
+        end
+
+        context 'does not match' do
+          let(:query) do
+            {'questions.answers.position' => 2}
+          end
+
+          it_behaves_like 'is false'
+        end
+      end
+
+      context 'field operator' do
+        # Test string and symbol operators
+        ['$gt', :$gt].each do |op|
+          context op.inspect do
+            context 'matches' do
+              let(:query) do
+                {'questions.answers.position' => {op => 2}}
+              end
+
+              it_behaves_like 'is true'
+            end
+
+            context 'does not match' do
+              let(:query) do
+                {'questions.answers.position' => {op => 4}}
+              end
+
+              it_behaves_like 'is false'
+            end
+          end
+        end
+      end
+
+      context 'array index' do
+        context 'matches' do
+          let(:query) do
+            {'questions.answers.1' => {position: 4}}
+          end
+
+          it_behaves_like 'is true'
+        end
+
+        context 'does not match' do
+          let(:query) do
+            {'questions.answers.0' => {position: 4}}
+          end
+
+          it_behaves_like 'is false'
+        end
+      end
+    end
+  end
+end

data/spec/integration/server_query_spec.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+
+# This file serves as a record of server query behavior.
+
+describe 'Server queries' do
+
+  context 'scalar operator on scalar field' do
+    let!(:document) do
+      Survey.create!(
+        questions: [Question.new(
+          answers: [Answer.new(position: 3)],
+        )],
+      )
+    end
+
+    let(:query) do
+      {'questions.answers.position' => {'$gt' => 2}}
+    end
+
+    it 'finds' do
+      Survey.collection.find(query).to_a.should == [document.attributes]
+    end
+  end
+
+  context 'scalar operator on array field' do
+    let!(:document) do
+      Bar.create!(
+        questions: [
+          answers: [
+            position: [3],
+          ],
+        ],
+      )
+    end
+
+    context '$eq with scalar on array field' do
+      let(:query) do
+        {'questions.answers.position' => {'$eq' => 3}}
+      end
+
+      it 'finds' do
+        Bar.collection.find(query).to_a.should == [document.attributes.with_indifferent_access]
+      end
+    end
+
+    context '$ne with scalar on array field' do
+      context 'same value as array item' do
+        let(:query) do
+          {'questions.answers.position' => {'$ne' => 3}}
+        end
+
+        it 'matches array and does not find' do
+          Bar.collection.find(query).to_a.should == []
+        end
+      end
+
+      context 'different value from array items' do
+        let(:query) do
+          {'questions.answers.position' => {'$ne' => 2}}
+        end
+
+        it 'finds' do
+          Bar.collection.find(query).to_a.should == [document.attributes.with_indifferent_access]
+        end
+      end
+    end
+
+    context '$gt on array field' do
+      let(:query) do
+        {'questions.answers.position' => {'$gt' => 2}}
+      end
+
+      it 'finds' do
+        # This finds the document - https://jira.mongodb.org/browse/DOCSP-10717
+        Bar.collection.find(query).to_a.should == [document.attributes.with_indifferent_access]
+      end
+    end
+
+    context '$in on a double array field' do
+      let!(:document) do
+        Bar.create!(
+          questions: [
+            answers: [
+              position: [[3]],
+            ],
+          ],
+        )
+      end
+
+      let(:query) do
+        {'questions.answers.position' => {'$in' => [3]}}
+      end
+
+      it 'does not find' do
+        Bar.collection.find(query).to_a.should == []
+      end
+    end
+
+    context '$in on an array field' do
+      let!(:document) do
+        Bar.create!(
+          questions: [
+            answers: [
+              position: [3],
+            ],
+          ],
+        )
+      end
+
+      let(:query) do
+        {'questions.answers.position' => {'$in' => [3]}}
+      end
+
+      it 'finds' do
+        Bar.collection.find(query).to_a.should == [document.attributes.with_indifferent_access]
+      end
+    end
+
+    context '$in on a scalar field' do
+      let!(:document) do
+        Bar.create!(
+          questions: [
+            answers: [
+              position: 3,
+            ],
+          ],
+        )
+      end
+
+      let(:query) do
+        {'questions.answers.position' => {'$in' => [3]}}
+      end
+
+      it 'finds' do
+        Bar.collection.find(query).to_a.should == [document.attributes.with_indifferent_access]
+      end
+    end
+  end
+end