mongoid 7.0.13 → 8.0.8

data/spec/integration/matcher_operator_data/type_code_with_scope.yml

@@ -0,0 +1,26 @@
+- name: existing field - matches Code with Scope
+  document:
+    code: !ruby/object:BSON::CodeWithScope
+      javascript: "this.value = name"
+      scope: {name: "sid"}
+  query:
+    code:
+      $type: 15
+  matches: true
+
+- name: existing field - does not match Code with Scope
+  document:
+    code: 42
+  query:
+    code:
+      $type: 15
+  matches: false
+
+- name: Code - does not match
+  document:
+    code: !ruby/object:BSON::Code
+      javascript: "var foo = 42;"
+  query:
+    code:
+      $type: 15
+  matches: false

data/spec/integration/matcher_operator_data/type_date.yml

@@ -0,0 +1,39 @@
+- name: existing field - matches date with date_field
+  document:
+    date_field: 2020-11-19
+  query:
+    date_field:
+      $type: 9
+  matches: true
+
+- name: existing field - matches date with time_field
+  document:
+    time_field: 2020-11-19 00:00:00
+  query:
+    time_field:
+      $type: 9
+  matches: true
+
+- name: existing field - matches date with datetime_field
+  document:
+    datetime_field: 2020-11-19 00:00:00
+  query:
+    datetime_field:
+      $type: 9
+  matches: true
+
+- name: existing field - matches date with default field
+  document:
+    day: 2020-11-19
+  query:
+    day:
+      $type: 9
+  matches: true
+
+- name: existing field - does not match date
+  document:
+    name: 3
+  query:
+    name:
+      $type: 9
+  matches: false

data/spec/integration/matcher_operator_data/type_db_pointer.yml

@@ -0,0 +1,19 @@
+- name: existing field - matches DBPointer
+  document:
+    ptr: !ruby/object:BSON::DbPointer
+      ref: "collection"
+      id: !ruby/object:BSON::ObjectId
+        raw_data: !binary |-
+          Xt0Zj+G4MlyV5hyJ
+  query:
+    ptr:
+      $type: 12
+  matches: true
+
+- name: existing field - does not match DBPointer
+  document:
+    ptr: 3
+  query:
+    ptr:
+      $type: 12
+  matches: false

data/spec/integration/matcher_operator_data/type_decimal.yml

@@ -0,0 +1,41 @@
+- name: Decimal128 in untyped field - matches
+  document:
+    number: !ruby/object:BSON::Decimal128
+      low: 4224
+      high: 3475653012423180288
+  query:
+    number:
+      $type: 19
+  matches: true
+  min_server_version: 3.4
+
+- name: Decimal128 field - matches
+  document:
+    decimal128_field: !ruby/object:BSON::Decimal128
+      low: 4224
+      high: 3475653012423180288
+  query:
+    decimal128_field:
+      $type: 19
+  matches: true
+  min_server_version: 3.4
+
+- name: existing field - does not match decimal
+  document:
+    name: "foo"
+  query:
+    name:
+      $type: 19
+  matches: false
+  min_server_version: 3.4
+
+# Requires :map_big_decimal_to_decimal128 option to be true.
+- name: BigDecimal field - matches
+  document:
+    big_decimal_field: !ruby/object:BigDecimal
+      18:0.42e2
+  query:
+    big_decimal_field:
+      $type: 19
+  matches: true
+  min_server_version: 3.4

data/spec/integration/matcher_operator_data/type_double.yml

@@ -0,0 +1,15 @@
+- name: float - matches
+  document:
+    pi: 3.14
+  query:
+    pi:
+      $type: 1
+  matches: true
+
+- name: integer - does not match
+  document:
+    pi: 3
+  query:
+    pi:
+      $type: 1
+  matches: false

data/spec/integration/matcher_operator_data/type_int32.yml

@@ -0,0 +1,33 @@
+- name: bson int32 - matches
+  document:
+    pi: !ruby/object:BSON::Int32
+      value: 3
+  query:
+    pi:
+      $type: 16
+  matches: true
+
+- name: small integer - matches
+  document:
+    pi: 3
+  query:
+    pi:
+      $type: 16
+  matches: true
+
+- name: big integer - does not match
+  document:
+    # Exactly 2**32
+    pi: 4294967296
+  query:
+    pi:
+      $type: 16
+  matches: false
+
+- name: float - does not match
+  document:
+    pi: 3.14
+  query:
+    pi:
+      $type: 16
+  matches: false

data/spec/integration/matcher_operator_data/type_int64.yml

@@ -0,0 +1,33 @@
+- name: bson int64 - matches
+  document:
+    number: !ruby/object:BSON::Int64
+      value: 392141
+  query:
+    number:
+      $type: 18
+  matches: true
+
+- name: small integer - does not match
+  document:
+    pi: 3
+  query:
+    pi:
+      $type: 18
+  matches: false
+
+- name: big integer - matches
+  document:
+    # Exactly 2**32
+    pi: 4294967296
+  query:
+    pi:
+      $type: 18
+  matches: true
+
+- name: existing field - does not match long
+  document:
+    name: "foo"
+  query:
+    name:
+      $type: 18
+  matches: false

data/spec/integration/matcher_operator_data/type_max_key.yml

@@ -0,0 +1,17 @@
+- name: existing field - matches MaxKey
+  document:
+    pi: !ruby/object:BSON::MaxKey
+      # dummy field so MaxKey gets constructed
+      test: 42
+  query:
+    pi:
+      $type: 127
+  matches: true
+
+- name: existing field - does not match MaxKey
+  document:
+    pi: 3
+  query:
+    pi:
+      $type: 127
+  matches: false

data/spec/integration/matcher_operator_data/type_min_key.yml

@@ -0,0 +1,17 @@
+- name: existing field - matches MinKey
+  document:
+    pi: !ruby/object:BSON::MinKey
+      # dummy field so MinKey gets constructed
+      test: 42
+  query:
+    pi:
+      $type: -1
+  matches: true
+
+- name: existing field - does not match MinKey
+  document:
+    pi: 3
+  query:
+    pi:
+      $type: -1
+  matches: false

data/spec/integration/matcher_operator_data/type_null.yml

@@ -0,0 +1,23 @@
+- name: existing field - matches
+  document:
+    name:
+  query:
+    name:
+      $type: 10
+  matches: true
+
+- name: missing field - does not match
+  document:
+    x:
+  query:
+    name:
+      $type: 10
+  matches: false
+
+- name: existing field - does not match
+  document:
+    pi: 3
+  query:
+    pi:
+      $type: 10
+  matches: false

data/spec/integration/matcher_operator_data/type_object.yml

@@ -0,0 +1,23 @@
+- name: hash value - matches
+  document:
+    name: {first_name: "bob"}
+  query:
+    name:
+      $type: 3
+  matches: true
+
+- name: array value - does not match
+  document:
+    name: [1]
+  query:
+    name:
+      $type: 3
+  matches: false
+
+- name: existing field - does not match Object
+  document:
+    pi: 3
+  query:
+    pi:
+      $type: 3
+  matches: false

data/spec/integration/matcher_operator_data/type_object_id.yml

@@ -0,0 +1,25 @@
+- name: existing field - matches ObjectId
+  document:
+    new_id: !ruby/object:BSON::ObjectId
+      raw_data: !binary |-
+        Xt0Zj+G4MlyV5hyJ
+  query:
+    new_id:
+      $type: 7
+  matches: true
+
+- name: integer - does not match
+  document:
+    pi: 3
+  query:
+    pi:
+      $type: 7
+  matches: false
+
+- name: string - does not match
+  document:
+    pi: hello
+  query:
+    pi:
+      $type: 7
+  matches: false

data/spec/integration/matcher_operator_data/type_regex.yml

@@ -0,0 +1,44 @@
+- name: bson regexp in untyped field - matches
+  document:
+    name: !ruby/object:BSON::Regexp::Raw
+      pattern: /test/
+      options: ''
+  query:
+    name:
+      $type: 11
+  matches: true
+
+- name: ruby regexp in untyped field - matches
+  document:
+    name: /test/
+  query:
+    name:
+      $type: 11
+  # Regexp is serialized as a string
+  matches: false
+
+- name: ruby regexp field - matches
+  document:
+    regexp_field: /test/
+  query:
+    regexp_field:
+      $type: 11
+  matches: true
+
+- name: bson regexp field - matches
+  document:
+    bson_regexp_field: !ruby/object:BSON::Regexp::Raw
+      pattern: /test/
+      options: ''
+  query:
+    bson_regexp_field:
+      $type: 11
+  matches: true
+
+- name: existing field - does not match regex
+  document:
+    pi: 3
+  query:
+    pi:
+      $type: 11
+  matches: false

data/spec/integration/matcher_operator_data/type_string.yml

@@ -0,0 +1,15 @@
+- name: existing field - matches string
+  document:
+    name: bob
+  query:
+    name:
+      $type: 2
+  matches: true
+
+- name: existing field - does not match string
+  document:
+    pi: 3
+  query:
+    pi:
+      $type: 2
+  matches: false

data/spec/integration/matcher_operator_data/type_symbol.yml

@@ -0,0 +1,32 @@
+- name: symbol in untyped field - matches
+  document:
+   name: :hello
+  query:
+    name:
+      $type: 14
+  matches: true
+
+- name: symbol field - matches
+  document:
+    symbol_field: :hello
+  query:
+    symbol_field:
+      $type: 14
+  matches: true
+
+- name: bson symbol - matches
+  document:
+    bson_symbol_field: !ruby/object:BSON::Symbol::Raw
+      symbol: hello
+  query:
+    bson_symbol_field:
+      $type: 14
+  matches: true
+
+- name: string field - does not match
+  document:
+    pi: hello
+  query:
+    pi:
+      $type: 14
+  matches: false

data/spec/integration/matcher_operator_data/type_timestamp.yml

@@ -0,0 +1,25 @@
+- name: existing field - matches timestamp
+  document:
+    time: !ruby/object:BSON::Timestamp
+      seconds: 4
+      increment: 2
+  query:
+    time:
+      $type: 17
+  matches: true
+
+- name: existing field - does not match timestamp
+  document:
+    name: 3
+  query:
+    name:
+      $type: 17
+  matches: false
+
+- name: Ruby Time instance - does not match
+  document:
+    time_field: 2020-11-19 00:00:00
+  query:
+    time_field:
+      $type: 17
+  matches: false

data/spec/integration/matcher_operator_data/type_undefined.yml

@@ -0,0 +1,17 @@
+- name: existing field - matches undefined
+  document:
+    price: !ruby/object:BSON::Undefined
+      # dummy field so Undefined gets constructed
+      test: 42
+  query:
+    price:
+      $type: 6
+  matches: true
+
+- name: existing field - does not match undefined
+  document:
+    pi: 3
+  query:
+    pi:
+      $type: 6
+  matches: false

data/spec/integration/matcher_operator_spec.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+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
+  config_override :map_big_decimal_to_decimal128, true
+
+  Dir[File.join(File.dirname(__FILE__), 'matcher_operator_data', '*.yml')].sort.each do |path|
+    context File.basename(path) do
+      permitted_classes = [ BigDecimal,
+                            Date,
+                            Time,
+                            Range,
+                            Regexp,
+                            Symbol,
+                            BSON::Binary,
+                            BSON::Code,
+                            BSON::CodeWithScope,
+                            BSON::DbPointer,
+                            BSON::Decimal128,
+                            BSON::Int32,
+                            BSON::Int64,
+                            BSON::MaxKey,
+                            BSON::MinKey,
+                            BSON::ObjectId,
+                            BSON::Regexp::Raw,
+                            BSON::Symbol::Raw,
+                            BSON::Timestamp,
+                            BSON::Undefined ]
+
+      specs = YAML.safe_load(File.read(path), permitted_classes: permitted_classes, aliases: true)
+
+      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