mongoid 5.4.1 → 7.4.0

data/spec/mongoid/interceptable_spec_models.rb

@@ -0,0 +1,76 @@
+module InterceptableSpec
+  class CallbackRegistry
+    def initialize
+      @calls = []
+    end
+
+    def record_call(cls, cb)
+      @calls << [cls, cb]
+    end
+
+    attr_reader :calls
+  end
+
+  module CallbackTracking
+    extend ActiveSupport::Concern
+
+    included do
+      %i(
+        validation save create update
+      ).each do |what|
+        %i(before after).each do |whn|
+          send("#{whn}_#{what}", "#{whn}_#{what}_stub".to_sym)
+          define_method("#{whn}_#{what}_stub") do
+            callback_registry.record_call(self.class, "#{whn}_#{what}".to_sym)
+          end
+        end
+      end
+    end
+  end
+
+  class CbParent
+    include Mongoid::Document
+
+    def initialize(callback_registry)
+      @callback_registry = callback_registry
+      super()
+    end
+
+    attr_reader :callback_registry
+
+    embeds_many :cb_children
+    embeds_many :cb_cascaded_children, cascade_callbacks: true
+
+    include CallbackTracking
+  end
+
+  class CbChild
+    include Mongoid::Document
+
+    embedded_in :cb_parent
+
+    def initialize(callback_registry, options)
+      @callback_registry = callback_registry
+      super(options)
+    end
+
+    attr_reader :callback_registry
+
+    include CallbackTracking
+  end
+
+  class CbCascadedChild
+    include Mongoid::Document
+
+    embedded_in :cb_parent
+
+    def initialize(callback_registry, options)
+      @callback_registry = callback_registry
+      super(options)
+    end
+
+    attr_reader :callback_registry
+
+    include CallbackTracking
+  end
+end

data/spec/mongoid/loggable_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Mongoid::Loggable do

data/spec/mongoid/matcher/extract_attribute_data/numeric_keys.yml

@@ -0,0 +1,104 @@
+- name: string key - matches
+  document:
+    # Document field names in MongoDB are always strings.
+    '42': foo
+  # The paths are also always strings.
+  key: '42'
+  
+  result:
+    - foo
+
+- name: string key - does not match
+  document:
+    # Document field names in MongoDB are always strings.
+    '42': foo
+  # The paths are also always strings.
+  key: '4'
+  
+  result: []
+
+- name: array value - matches
+  document:
+    '42':
+      - foo
+  key: '42'
+  
+  result:
+    - ['foo']
+
+- name: subfield of numeric key - matches
+  document:
+    '42':
+      foo: bar
+  key: 42.foo
+  
+  result: 
+    - bar
+
+- name: numeric key under array
+  document:
+    a:
+      -
+        '42': bar
+
+  key: a.42
+
+  result: 
+    - bar
+
+- name: multiple values under numeric key under array
+  document: &numeric-key-under-array
+    a:
+      -
+        '42': bar
+      -
+        '42': foo
+
+  key: a.42
+
+  result: 
+    - bar
+    - foo
+
+- name: array indexing with values under numeric key under array
+  document: *numeric-key-under-array
+
+  key: a.1
+
+  result: 
+    - 
+      '42': foo
+
+- name: multiple values under array under numeric key
+  document:
+    a:
+      '42':
+        -
+          foo: bar
+        -       
+          foo: baq
+
+  key: a.42.foo
+
+  result: 
+    - bar
+    - baq
+
+- name: path component interpretable as both array index and hash key
+  document: 
+    a:
+      -
+        '1': bar
+      -
+        '1': foo
+
+  key: a.1
+
+  result: 
+    # The order of these results isn't guaranteed:
+    # 1 interpreted as the array index:
+    -
+      '1': foo
+    # 1 interpreted as hash key:
+    - bar
+    - foo

data/spec/mongoid/matcher/extract_attribute_data/traversal.yml

@@ -0,0 +1,239 @@
+- name: scalar retrieval
+  document:
+    name: foo
+  key: name
+  
+  result: 
+    - foo
+
+- name: scalar leaf
+  document: &foo-bar-foo-bar-2
+    foo:
+      bar:
+        foo:
+          bar:
+            2
+  key: foo.bar.foo.bar
+  
+  result:
+    - 2
+
+- name: scalar non-leaf
+  document: *foo-bar-foo-bar-2
+  key: foo.bar
+  
+  result:
+    -
+      foo:
+        bar:
+          2
+
+- name: null leaf
+  document:
+    name:
+  key: name
+  
+  result: 
+    - ~
+
+- name: array leaf
+  document: &foo-bar-foo-bar-array-2
+    foo:
+      bar:
+        foo:
+          bar:
+            - 2
+  key: foo.bar.foo.bar
+  
+  result:
+    - [2]
+
+- name: scalar non-leaf
+  document: *foo-bar-foo-bar-array-2
+  key: foo.bar
+  
+  result:
+    -
+      foo:
+        bar:
+          - 2
+
+- name: array non-leaf
+  document: &foo-bar-array-foo-bar-2
+    foo:
+      -
+        bar:
+          foo:
+            bar:
+              2
+  key: foo.bar.foo.bar
+  
+  result:
+    - 2
+
+- name: array non-leaf with non-leaf query
+  document: *foo-bar-array-foo-bar-2
+  key: foo.bar
+  
+  result:
+    -
+      foo:
+        bar:
+          2
+
+- name: array non-leaf with query for missing non-leaf key
+  document: *foo-bar-array-foo-bar-2
+  key: foo.missing
+  
+  result: []
+
+- name: path past end of document
+  document: &foo-hello-world
+    foo:
+      hello: world
+  key: foo.bar.foo.bar
+  
+  result: []
+
+- name: query for missing leaf key
+  document: *foo-hello-world
+  key: foo.bar
+  
+  result: []
+
+- name: numeric path component when traversing hash
+  document:
+    foo:
+      "10":
+        42
+  key: "foo.10"
+
+  result: 
+    - 42
+
+- name: array index - hash leaf
+  document: &foo-one-two
+    foo:
+      - one: 1
+      - two: 2
+    bar: [3, 4]
+  key: foo.1.two
+  
+  result: 
+    - 2
+
+- name: array index - hash non-leaf
+  document: *foo-one-two
+  key: foo.1
+  
+  result:
+    -
+      two: 2
+
+- name: array index - scalar leaf
+  document: *foo-one-two
+  key: bar.1
+  
+  result: 
+    - 4
+
+- name: array index - scalar leaf - missing
+  document: *foo-one-two
+  key: bar.2
+  
+  result: []
+
+- name: array index - scalar leaf - missing with further hash subscription
+  document: *foo-one-two
+  key: bar.2.any
+  
+  result: []
+
+- name: non-sequential nested arrays - hash leaf - one value
+  document: &books-authors
+    books:
+      -
+        authors:
+          - name: Steve
+      -
+        authors:
+          - name: Boris
+          - name: Pasha
+  key: books.0.authors.name
+  
+  result:
+    - Steve
+
+- name: non-sequential nested arrays - hash non-leaf - one value
+  document: *books-authors
+  key: books.0
+  
+  result:
+    -
+      authors:
+        - name: Steve
+
+- name: non-sequential nested arrays - hash non-leaf - multiple values
+  document: *books-authors
+  key: books.1
+  
+  result:
+    -
+      authors:
+        - name: Boris
+        - name: Pasha
+
+- name: sequential nested arrays - numerically indexed leaf
+  document: &groups
+    groups:
+      - [1]
+  key: groups.0.0
+  
+  result: 
+    - 1
+
+- name: sequential nested arrays - numerically indexed leaf - missing
+  document: *groups
+  key: groups.0.1
+  
+  result: []
+
+- name: sequential nested arrays - missing hash path through non-leaf
+  document: *groups
+  key: groups.missing
+  
+  result: []
+
+- name: sequential nested arrays - missing hash path through leaf
+  document: *groups
+  key: groups.0.missing
+  
+  result: []
+
+- name: sequential nested arrays - missing hash path past leaf
+  document: *groups
+  key: groups.0.0.missing
+  
+  result: []
+
+- name: mix of arrays and hashes in an array
+  document:
+    foo:
+      -
+        -
+          bar: 1
+      - bar: 2
+  key: foo.bar
+  
+  result: 
+    - 2
+
+- name: numeric index through a primitive value not supporting subscription operator
+  document:
+    occupants:
+      -
+        age: 20
+  key:
+    occupants.0.age.0
+    
+  result: []

data/spec/mongoid/matcher/extract_attribute_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'Matcher.extract_attribute' do
+  Dir[File.join(File.dirname(__FILE__), 'extract_attribute_data', '*.yml')].sort.each do |path|
+    context File.basename(path) do
+      specs = if RUBY_VERSION.start_with?("2.5")
+                YAML.safe_load(File.read(path), [], [], true)
+              else
+                YAML.safe_load(File.read(path), aliases: true)
+              end
+
+      specs.each do |spec|
+        context spec['name'] do
+
+          if spec['pending']
+            pending spec['pending'].to_s
+          end
+
+          let(:document) do
+            spec['document']
+          end
+
+          let(:key) { spec['key'] }
+
+          let(:actual) do
+            Mongoid::Matcher.extract_attribute(document, key)
+          end
+
+          let(:expected) { spec.fetch('result') }
+
+          it 'has the expected result' do
+            actual.should == expected
+          end
+        end
+      end
+    end
+  end
+end

data/spec/mongoid/persistable/creatable_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Mongoid::Persistable::Creatable do
@@ -140,29 +142,84 @@ describe Mongoid::Persistable::Creatable do
     end
 
     context "when the document is a subclass of a root class" do
+      context "when using the default discriminator key" do
+        let!(:browser) do
+          Browser.create(version: 3, name: "Test")
+        end
 
-      let!(:browser) do
-        Browser.create(version: 3, name: "Test")
-      end
+        let(:collection) do
+          Canvas.collection
+        end
 
-      let(:collection) do
-        Canvas.collection
-      end
+        let(:attributes) do
+          collection.find({ name: "Test"}).first
+        end
 
-      let(:attributes) do
-        collection.find({ name: "Test"}).first
-      end
+        it "persists the versions" do
+          expect(attributes["version"]).to eq(3)
+        end
 
-      it "persists the versions" do
-        expect(attributes["version"]).to eq(3)
+        it "persists the type" do
+          expect(attributes["_type"]).to eq("Browser")
+        end
+
+        it "persists the attributes" do
+          expect(attributes["name"]).to eq("Test")
+        end
       end
 
-      it "persists the type" do
-        expect(attributes["_type"]).to eq("Browser")
+      context "when using a custom discriminator key" do
+        before do
+          Canvas.discriminator_key = "dkey"
+        end
+
+        after do
+          Canvas.discriminator_key = nil
+        end
+
+        let!(:browser) do
+          Browser.create(version: 3, name: "Test")
+        end
+
+        let(:collection) do
+          Canvas.collection
+        end
+
+        let(:attributes) do
+          collection.find({ name: "Test"}).first
+        end
+
+        it "persists the new discriminator key" do
+          expect(attributes["dkey"]).to eq("Browser")
+        end
       end
 
-      it "persists the attributes" do
-        expect(attributes["name"]).to eq("Test")
+      context "when using a custom discriminator key and discriminator value" do
+        before do
+          Canvas.discriminator_key = "dkey"
+          Browser.discriminator_value = "dvalue"
+        end
+
+        after do
+          Canvas.discriminator_key = nil
+          Browser.discriminator_value = nil
+        end
+
+        let!(:browser) do
+          Browser.create(version: 3, name: "Test")
+        end
+
+        let(:collection) do
+          Canvas.collection
+        end
+
+        let(:attributes) do
+          collection.find({ name: "Test"}).first
+        end
+
+        it "persists the new discriminator key" do
+          expect(attributes["dkey"]).to eq("dvalue")
+        end
       end
     end
 
@@ -204,7 +261,7 @@ describe Mongoid::Persistable::Creatable do
         expect(Canvas.where(name: "Testy").first).to eq(firefox)
       end
 
-      it "returnss on of this subclasses if you find by _type" do
+      it "returns on of this subclasses if you find by _type" do
         expect(Canvas.where(:_type.in => ['Firefox']).count).to eq(1)
       end
     end
@@ -263,8 +320,8 @@ describe Mongoid::Persistable::Creatable do
       end
 
       it "does not bleed relations from one subclass to another" do
-        expect(Truck.relations.keys).to eq(%w/ shipping_container driver bed /)
-        expect(Car.relations.keys).to eq(%w/ shipping_container driver /)
+        expect(Truck.relations.keys).to eq(%w/ shipping_container driver crates seats bed /)
+        expect(Car.relations.keys).to eq(%w/ shipping_container driver crates seats /)
       end
 
       context "when appending new documents" do
@@ -294,8 +351,8 @@ describe Mongoid::Persistable::Creatable do
       context "when building related documents" do
 
         before do
-          container.vehicles.build({}, Car).save
-          container.vehicles.build({}, Truck).save
+          container.vehicles.build({}, Car).save!
+          container.vehicles.build({}, Truck).save!
         end
 
         it "allows STI from the build call" do
@@ -340,17 +397,45 @@ describe Mongoid::Persistable::Creatable do
       end
 
       context "#find_or_initialize_by" do
+        context "when using the default discriminator key" do
+          before do
+            container.vehicles.find_or_initialize_by({ driver_id: driver.id }, Car)
+          end
 
-        before do
-          container.vehicles.find_or_initialize_by({ driver_id: driver.id }, Car)
-        end
+          it "initializes the given type document" do
+            expect(container.vehicles.map(&:class)).to eq([ Car ])
+          end
 
-        it "initializes the given type document" do
-          expect(container.vehicles.map(&:class)).to eq([ Car ])
+          it "initializes with the given attributes" do
+            expect(container.vehicles.map(&:driver)).to eq([ driver ])
+          end
+
+          it "initializes with a type field that equals the class" do
+            expect(
+              container.vehicles.first.attributes["_type"]
+            ).to eq("Car")
+          end
         end
 
-        it "initializes with the given attributes" do
-          expect(container.vehicles.map(&:driver)).to eq([ driver ])
+        context "when using a custom discriminator key" do
+          before do
+            Vehicle.discriminator_key = "dkey"
+            container.vehicles.find_or_initialize_by({ driver_id: driver.id }, Car)
+          end
+
+          it "initializes the given type document" do
+            expect(container.vehicles.map(&:class)).to eq([ Car ])
+          end
+
+          it "initializes with the given attributes" do
+            expect(container.vehicles.map(&:driver)).to eq([ driver ])
+          end
+
+          it "initializes with a dkey field that equals the class" do
+            expect(
+              container.vehicles.first.attributes["dkey"]
+            ).to eq("Car")
+          end
         end
       end
 
@@ -523,13 +608,18 @@ describe Mongoid::Persistable::Creatable do
       context "when a unique index exists" do
 
         before do
+          Person.index({ ssn: 1 }, { unique: true })
           Person.create_indexes
         end
 
+        after do
+          Person.collection.drop
+        end
+
         it "raises an error" do
           expect {
             4.times { Person.create!(ssn: "555-55-1029") }
-          }.to raise_error
+          }.to raise_error(Mongo::Error::OperationFailure)
         end
       end
     end
@@ -562,7 +652,7 @@ describe Mongoid::Persistable::Creatable do
       end
     end
 
-    context "when a callback returns false" do
+    context "when a callback aborts the chain" do
 
       it "raises a callback error" do
         expect { Oscar.create! }.to raise_error(Mongoid::Errors::Callback)