mongoid 7.1.11 → 7.2.0.rc1

data/spec/integration/discriminator_value_spec.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe "#discriminator_key" do 
+
+  context "when the discriminator value is not set on a class" do
+    let(:piano) do 
+      Piano.new
+    end
+
+    let(:guitar) do 
+      Guitar.new
+    end  
+    
+    it "sets the child discriminator key to _type: Piano" do
+      expect(piano._type).to eq("Piano")
+    end
+
+    it "sets the child discriminator key to _type: Guitar" do
+      expect(guitar._type).to eq("Guitar")
+    end
+  end
+
+  context "when the discriminator_value is set on a child" do
+    before do 
+      Piano.discriminator_value = "keys"
+    end
+
+    after do 
+      Piano.discriminator_value = nil
+    end
+
+    let(:piano) do 
+      Piano.new
+    end
+
+    it "has the correct discriminator value on the instance" do 
+      expect(piano._type).to eq("keys")
+    end
+  end
+
+  context "when the discriminator key and value are set on a child" do
+    before do 
+      Piano.discriminator_value = "keys"
+      Instrument.discriminator_key = "dkey"
+    end
+
+    after do 
+      Piano.discriminator_value = nil
+      Instrument.discriminator_key = nil
+    end
+
+
+    let(:piano) do 
+      Piano.new
+    end
+
+    it "has the correct discriminator value on the instance" do 
+      expect(piano.dkey).to eq("keys")
+    end
+  end
+
+  context "when adding to the db" do
+    context "when not changing the discriminator value" do 
+      before do 
+        Piano.create!
+      end
+
+      it "has the correct count" do 
+        expect(Piano.count).to eq(1)
+      end
+
+      it "has the correct count in the parent" do 
+        expect(Instrument.count).to eq(1)
+      end
+
+      it "has zero count in the sibling" do 
+        expect(Guitar.count).to eq(0)
+      end
+    end
+
+    context "when changing the discriminator value" do 
+      before do 
+        Piano.discriminator_value = "keys"
+        Piano.create!
+      end
+
+      after do 
+        Piano.discriminator_value = nil
+      end
+
+      it "has the correct count" do 
+        expect(Piano.count).to eq(1)
+      end
+
+      it "has the correct count in the parent" do 
+        expect(Instrument.count).to eq(1)
+      end
+
+      it "has zero count in the sibling" do 
+        expect(Guitar.count).to eq(0)
+      end
+    end
+
+    context "when changing the discriminator key/value" do 
+      before do 
+        Instrument.discriminator_key = "dkey"
+        Piano.discriminator_value = "keys"
+        Piano.create!
+      end
+
+      after do 
+        Instrument.discriminator_key = nil
+        Piano.discriminator_value = nil
+      end
+
+      it "has the correct count" do 
+        expect(Piano.count).to eq(1)
+      end
+
+      it "has the correct count in the parent" do 
+        expect(Instrument.count).to eq(1)
+      end
+
+      it "has zero count in the sibling" do 
+        expect(Guitar.count).to eq(0)
+      end
+    end
+
+    context "when calling count before changing the discriminator key/value" do 
+      before do 
+        Instrument.count
+        Instrument.discriminator_key = "dkey"
+        Piano.discriminator_value = "keys"
+        Piano.create!
+      end
+
+      after do 
+        Instrument.discriminator_key = nil
+        Piano.discriminator_value = nil
+      end
+
+      it "has the correct count" do 
+        expect(Piano.count).to eq(1)
+      end
+
+      it "has the correct count in the parent" do 
+        expect(Instrument.count).to eq(1)
+      end
+
+      it "has zero count in the sibling" do 
+        expect(Guitar.count).to eq(0)
+      end
+    end
+
+    context "when calling create before changing the discriminator key/value" do 
+      before do 
+        Piano.create!
+        Instrument.discriminator_key = "dkey"
+        Piano.discriminator_value = "keys"
+        Piano.create!
+      end
+
+      after do 
+        Instrument.discriminator_key = nil
+        Piano.discriminator_value = nil
+      end
+
+      it "has the correct count" do 
+        expect(Piano.count).to eq(1)
+      end
+
+      it "has the correct count in the parent" do 
+        expect(Instrument.count).to eq(2)
+      end
+
+      it "has zero count in the sibling" do 
+        expect(Guitar.count).to eq(0)
+      end
+    end
+
+    context "when there exists an unrecognizable discriminator value in the database" do 
+      before do 
+        Piano.discriminator_value = "keys"
+        Piano.create!(_type: "dvalue")
+      end
+
+      after do 
+        Piano.discriminator_value = nil
+      end
+
+      it "is not considered a piano" do 
+        expect(Piano.count).to eq(0)
+      end
+
+      it "is considered an Instrument, the parent" do 
+        expect(Instrument.count).to eq(1)
+      end
+
+      it "has zero count in the sibling" do 
+        expect(Guitar.count).to eq(0)
+      end
+    end
+  end
+end

data/spec/integration/document_spec.rb

@@ -19,25 +19,4 @@ describe Mongoid::Document do
       DelegatingPatient.default_client.should be Mongoid.default_client
     end
   end
-
-  describe '#reload' do
-    context 'when changing shard key value' do
-      require_topology :sharded
-
-      let(:profile) do
-        # Profile shard_key :name
-        Profile.create!(name: "Alice")
-      end
-
-      it "successfully reloads the document after saving an update to the sharded field" do
-        expect(profile.name).to eq("Alice")
-        profile.name = "Bob"
-        profile.save!
-
-        profile.reload
-
-        expect(profile.name).to eq("Bob")
-      end
-    end
-  end
 end

data/spec/integration/{matchable_spec.rb → matcher_examples_spec.rb}

@@ -3,6 +3,11 @@
 
 require 'spec_helper'
 
+# Some of these tests duplicate the tests in matcher_operator_spec.rb.
+# The tests in this file are retained because they use model instances
+# rather than simple hashes as the YAML tests do, hence in theory these tests
+# could provide additional coverage.
+
 describe 'Matcher' do
   context 'when attribute is a scalar' do
     describe 'exact match' do
@@ -65,12 +70,12 @@ describe 'Matcher' do
       end
     end
 
-    describe 'range match on number' do
+    describe 'range match on scalar' do
 
       let!(:circuit) do
         Circuit.create!(buses: [
-          Bus.new(number: '10'),
-          Bus.new(number: '30'),
+          Bus.new(number: 10),
+          Bus.new(number: 30),
         ])
       end
 
@@ -79,9 +84,17 @@ describe 'Matcher' do
           Circuit.where('buses.number' => 10..15).first
         end
 
+        let(:not_found_circuit) do
+          Circuit.where('buses.number' => 35..45).first
+        end
+
         it 'finds' do
           expect(found_circuit).to eq(circuit)
         end
+
+        it 'does not find' do
+          expect(not_found_circuit).to be nil
+        end
       end
 
       describe 'Mongoid matcher' do
@@ -89,9 +102,17 @@ describe 'Matcher' do
           circuit.buses.where(number: 10..15).first
         end
 
+        let(:not_found_bus) do
+          circuit.buses.where(number: 12..15).first
+        end
+
         it 'finds' do
           expect(found_bus).to be circuit.buses.first
         end
+
+        it 'does not find' do
+          expect(not_found_bus).to be nil
+        end
       end
     end
 
@@ -445,17 +466,12 @@ describe 'Matcher' do
               {'number' => 1},
             ]}).first
           end
-        end
 
-        it 'is prohibited' do
-          # MongoDB prohibits $and operator in values when matching on
-          # fields. Mongoid does not have such a prohibition and
-          # also returns the address where different locations match the
-          # different branches.
-          pending 'Mongoid behavior differs from MongoDB'
-          expect do
-            actual_object_matching_condition
-          end.to raise_error(Mongoid::Errors::InvalidFind)
+          it 'is prohibited' do
+            expect do
+              actual_object_matching_condition
+            end.to raise_error(Mongoid::Errors::InvalidFieldOperator)
+          end
         end
       end
     end
@@ -502,17 +518,12 @@ describe 'Matcher' do
               {'number' => 1},
             ]}).first
           end
-        end
 
-        it 'is prohibited' do
-          # MongoDB prohibits $and operator in values when matching on
-          # fields. Mongoid does not have such a prohibition and
-          # also returns the address where different locations match the
-          # different branches.
-          pending 'Mongoid behavior differs from MongoDB'
-          expect do
-            actual_object_matching_condition
-          end.to raise_error(Mongoid::Errors::InvalidFind)
+          it 'is prohibited' do
+            expect do
+              actual_object_matching_condition
+            end.to raise_error(Mongoid::Errors::InvalidFieldOperator)
+          end
         end
       end
     end
@@ -520,9 +531,6 @@ describe 'Matcher' do
     describe '$not' do
       let!(:person) do
         Person.new(addresses: [
-          Address.new(locations: [
-            Location.new(name: 'City', number: 1),
-          ]),
           Address.new(locations: [
             # Both criteria are on the same object
             Location.new(name: 'Hall', number: 1),
@@ -542,9 +550,9 @@ describe 'Matcher' do
       end
 
       let(:actual_object_not_matching_condition) do
-        person.addresses.where(operator => [
-          {'locations.number' => {'$exists' => true}},
-        ]).first
+        person.addresses.where('locations.name' => {operator =>
+          {'$eq' => 'Hall'},
+        }).first
       end
 
       it_behaves_like 'a field operator', '$not'
@@ -573,17 +581,12 @@ describe 'Matcher' do
               {'number' => 1},
             ]}).first
           end
-        end
 
-        it 'is prohibited' do
-          # MongoDB prohibits $and operator in values when matching on
-          # fields. Mongoid does not have such a prohibition and
-          # also returns the address where different locations match the
-          # different branches.
-          pending 'Mongoid behavior differs from MongoDB'
-          expect do
-            actual_object_matching_condition
-          end.to raise_error(Mongoid::Errors::InvalidFind)
+          it 'is prohibited' do
+            expect do
+              actual_object_matching_condition
+            end.to raise_error(Mongoid::Errors::InvalidQuery)
+          end
         end
       end
     end
@@ -664,6 +667,20 @@ describe 'Matcher' do
         it 'finds' do
           expect(found_band).to eq(band)
         end
+
+        # https://jira.mongodb.org/browse/MONGOID-4911
+        context 'no match' do
+
+        let!(:band) do
+          Band.create!(records: [
+            Record.new(producers: [50]),
+          ])
+        end
+
+          it 'does not find' do
+            expect(found_band).to be nil
+          end
+        end
       end
 
       describe 'Mongoid matcher' do
@@ -671,8 +688,70 @@ describe 'Matcher' do
           band.records.where(producers: 100..200).first
         end
 
-        it 'finds' do
-          expect(found_record).to be band.records.first
+        it 'raises InvalidQuery' do
+          lambda do
+            found_record
+          end.should raise_error(Mongoid::Errors::InvalidQuery)
+        end
+      end
+    end
+  end
+
+  describe '$elemMatch' do
+    context 'hash match against scalar value in embeds_many' do
+      context 'string value' do
+        let(:band) do
+          Band.new(records: [
+            Record.new(producers: ['Sunrise']),
+          ])
+        end
+
+        it 'does not find' do
+          band.records.where(producers: {'$elemMatch': {foo: 'bar'}}).first.should be nil
+        end
+
+        context 'primitive value query' do
+
+          it 'does not find' do
+            lambda do
+              band.records.where(producers: {'$elemMatch': 'bar'}).first
+            end.should raise_error(Mongoid::Errors::InvalidQuery, /elemMatch requires a Hash operand/)
+          end
+        end
+
+        context '$not with primitive value' do
+
+          it 'does not find' do
+            lambda do
+              band.records.where(producers: {'$elemMatch': {'$not': 'bar'}}).first
+            end.should raise_error(Mongoid::Errors::InvalidQuery, /\$not argument must be a Hash or a regular expression/)
+          end
+        end
+
+        context '$not with regexp' do
+
+          it 'finds' do
+            band.records.where(producers: {'$elemMatch': {'$not': /bar/}}).count.should == 1
+          end
+        end
+
+        context '$not with operator' do
+
+          it 'finds' do
+            band.records.where(producers: {'$elemMatch': {'$not': {'$eq': 'bar'}}}).count.should == 1
+          end
+        end
+      end
+
+      context 'integer value' do
+        let(:band) do
+          Band.new(records: [
+            Record.new(producers: [42]),
+          ])
+        end
+
+        it 'does not find' do
+          band.records.where(producers: {'$elemMatch': {foo: 'bar'}}).first.should be nil
         end
       end
     end

data/spec/integration/matcher_operator_data/all.yml

@@ -0,0 +1,140 @@
+- name: attribute includes all condition values
+  document:
+    products: [1, 2, 3]
+  query:
+    products:
+      $all: [1, 2]
+  matches: true
+
+- name: attribute does not include all condition values
+  document:
+    products: [1, 2, 3]
+  query:
+    products:
+      $all: [1, 4]
+  matches: false
+
+- name: attribute value is empty
+  document:
+    products: []
+  query:
+    products:
+      $all: [1, 4]
+  matches: false
+
+- name: condition value is empty
+  document:
+    products: [1, 2, 3]
+  query:
+    products:
+      $all: []
+  matches: false
+
+- name: condition value is a matching native regexp
+  document:
+    positions: [ceo, cto]
+  query:
+    positions:
+      $all:
+        - !ruby/regexp /c.o/
+  matches: true
+
+- name: condition value is a not matching native regexp
+  document:
+    positions: [ceo, cto]
+  query:
+    positions:
+      $all:
+        - !ruby/regexp /a.o/
+  matches: false
+
+- name: condition value is a matching bson regexp
+  document:
+    positions: [ceo, cto]
+  query:
+    positions:
+      $all:
+        - !ruby/object:BSON::Regexp::Raw
+          pattern: c.o
+          options: ''
+  matches: true
+
+- name: condition value is a not matching bson regexp
+  document:
+    positions: [ceo, cto]
+  query:
+    positions:
+      $all:
+        - !ruby/object:BSON::Regexp::Raw
+          pattern: a.o
+          options: ''
+  matches: false
+
+- name: nil argument
+  document:
+    positions: [ceo, cto]
+  query:
+    positions:
+      $all: ~
+  error: true
+
+- name: numeric argument
+  document:
+    positions: [ceo, cto]
+  query:
+    positions:
+      $all: 42
+  error: true
+
+- name: hash argument
+  document:
+    positions: [ceo, cto]
+  query:
+    positions:
+      $all:
+        foo: bar
+  error: true
+
+- name: scalar argument that exists in target array
+  document:
+    positions: [ceo, cto]
+  query:
+    positions:
+      $all:
+        ceo
+  error: true
+
+- name: field value is null
+  document:
+    products: ~
+  query:
+    products:
+      $all: [1, 2]
+  matches: false
+
+- name: field value is numeric
+  document:
+    products: 42
+  query:
+    products:
+      $all: [42]
+  matches: true
+
+- name: field value is null and query is for null value
+  document:
+    products: ~
+  query:
+    products:
+      $all: [~]
+  matches: true
+
+- name: range - match
+  document:
+    products: [1, 2, 3]
+  query:
+    products:
+      $all: !ruby/range
+        begin: 1
+        end: 20
+        excl: false
+  error: true

data/spec/integration/matcher_operator_data/and.yml

@@ -0,0 +1,93 @@
+- name: simple expression - matching
+  document:
+    name: foo
+  query:
+    $and:
+      - name: foo
+  matches: true
+
+- name: simple expression - not matching
+  document:
+    name: foo
+  query:
+    $and:
+      - name: bar
+  matches: false
+
+- name: multiple expressions - matching
+  document:
+    name: foo
+    order: 1
+  query:
+    $and:
+      - name: foo
+      - order: 1
+  matches: true
+
+- name: multiple expressions - not matching
+  document:
+    name: foo
+    order: 1
+  query:
+    $and:
+      - name: bar
+      - order: 2
+  matches: false
+
+- name: no expressions (empty array)
+  document:
+    name: foo
+    order: 1
+  query:
+    $and: []
+  error: true
+
+- name: complex expression - matching
+  document:
+    name: foo
+  query:
+    $and:
+      - name:
+          $in: [foo]
+  matches: true
+
+- name: complex expression - not matching
+  document:
+    name: foo
+  query:
+    $and:
+      - name:
+          $gt: 1
+  matches: false
+
+- name: nil argument
+  document:
+    positions: [ceo, cto]
+  query:
+    $and: ~
+  error: true
+
+- name: numeric argument
+  document:
+    positions: [ceo, cto]
+  query:
+    $and: 42
+  error: true
+
+- name: hash argument
+  document:
+    positions: [ceo, cto]
+  query:
+    $and:
+      foo: bar
+  error: true
+
+- name: field value is null
+  document:
+    products: ~
+  query:
+    $and:
+      -
+        products:
+          $ne: a
+  matches: true