mongoid 7.1.11 → 7.2.0.rc1

data/spec/mongoid/indexable_spec.rb

@@ -191,6 +191,32 @@ describe Mongoid::Indexable do
         expect(spec.options).to eq(unique: false, background: true)
       end
     end
+
+    context "when using a custom discriminator_key" do 
+      context "when indexes have not been added" do
+        let(:klass) do
+          Class.new do
+            include Mongoid::Document
+            self.discriminator_key = "dkey"
+            def self.hereditary?
+              true
+            end
+          end
+        end
+  
+        before do
+          klass.add_indexes
+        end
+  
+        let(:spec) do
+          klass.index_specification(dkey: 1)
+        end
+  
+        it "adds the _type index" do
+          expect(spec.options).to eq(unique: false, background: true)
+        end
+      end
+    end
   end
 
   describe ".index" do
@@ -383,7 +409,7 @@ describe Mongoid::Indexable do
       end
     end
 
-    context "when providing a geospacial index" do
+    context "when providing a geospatial index" do
 
       before do
         klass.index({ location: "2d" }, { min: -200, max: 200, bits: 32 })
@@ -393,7 +419,7 @@ describe Mongoid::Indexable do
         klass.index_specification(location: "2d").options
       end
 
-      it "sets the geospacial index" do
+      it "sets the geospatial index" do
         expect(options).to eq({ min: -200, max: 200, bits: 32 })
       end
     end

data/spec/mongoid/inspectable_spec.rb

@@ -26,12 +26,39 @@ describe Mongoid::Inspectable do
       end
 
       it "displays defined fields" do
-        expect(inspected).to include("title: \"CEO\"")
+        expect(inspected).to include(%q,title: "CEO",)
       end
 
       it "displays field aliases" do
         expect(inspected).to include("t(test):")
       end
+
+      it "displays the default discriminator key" do 
+        expect(inspected).to include(%q,_type: "Person",)
+      end
+    end
+
+    context "when using a custom discriminator key" do
+
+      before do 
+        Person.discriminator_key = "dkey"
+      end
+
+      after do 
+        Person.discriminator_key = nil
+      end
+
+      let(:person) do
+        Person.new(title: "CEO")
+      end
+
+      let(:inspected) do
+        person.inspect
+      end
+
+      it "displays the new discriminator key" do 
+        expect(inspected).to include(%q,dkey: "Person",)
+      end
     end
 
     context "when allowing dynamic fields" do
@@ -45,7 +72,7 @@ describe Mongoid::Inspectable do
       end
 
       it "includes dynamic attributes" do
-        expect(inspected).to include("some_attribute: \"foo\"")
+        expect(inspected).to include(%q,some_attribute: "foo",)
       end
     end
   end

data/spec/mongoid/interceptable_spec.rb

@@ -1707,8 +1707,8 @@ describe Mongoid::Interceptable do
   context "when loading a model multiple times" do
 
     before do
-      load "spec/app/models/callback_test.rb"
-      load "spec/app/models/callback_test.rb"
+      load File.join(MODELS, "callback_test.rb")
+      load File.join(MODELS, "callback_test.rb")
     end
 
     let(:callback) do

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

@@ -0,0 +1,259 @@
+- name: scalar retrieval
+  document:
+    name: foo
+  key: name
+  
+  exists: true
+  value: foo
+  expanded: false
+
+- name: scalar leaf
+  document: &foo-bar-foo-bar-2
+    foo:
+      bar:
+        foo:
+          bar:
+            2
+  key: foo.bar.foo.bar
+  
+  exists: true
+  value: 2
+  expanded: false
+
+- name: scalar non-leaf
+  document: *foo-bar-foo-bar-2
+  key: foo.bar
+  
+  exists: true
+  value:
+    foo:
+      bar:
+        2
+  expanded: false
+
+- name: array leaf
+  document: &foo-bar-foo-bar-array-2
+    foo:
+      bar:
+        foo:
+          bar:
+            - 2
+  key: foo.bar.foo.bar
+  
+  exists: true
+  value:
+    - 2
+  expanded: false
+
+- name: scalar non-leaf
+  document: *foo-bar-foo-bar-array-2
+  key: foo.bar
+  
+  exists: true
+  value:
+    foo:
+      bar:
+        - 2
+  expanded: false
+
+- name: array non-leaf
+  document: &foo-bar-array-foo-bar-2
+    foo:
+      -
+        bar:
+          foo:
+            bar:
+              2
+  key: foo.bar.foo.bar
+  
+  exists: true
+  value:
+    - 2
+  expanded: true
+
+- name: array non-leaf with non-leaf query
+  document: *foo-bar-array-foo-bar-2
+  key: foo.bar
+  
+  exists: true
+  value:
+    -
+      foo:
+        bar:
+          2
+  expanded: true
+
+- name: array non-leaf with query for missing non-leaf key
+  document: *foo-bar-array-foo-bar-2
+  key: foo.missing
+  
+  exists: false
+  value: []
+  expanded: true
+
+- name: path past end of document
+  document: &foo-hello-world
+    foo:
+      hello: world
+  key: foo.bar.foo.bar
+  
+  exists: false
+  value: ~
+  expanded: false
+
+- name: query for missing leaf key
+  document: *foo-hello-world
+  key: foo.bar
+  
+  exists: false
+  value: ~
+  expanded: false
+
+- name: array index - hash leaf
+  document: &foo-one-two
+    foo:
+      - one: 1
+      - two: 2
+    bar: [3, 4]
+  key: foo.1.two
+  
+  exists: true
+  value: 2
+  expanded: false
+
+- name: array index - hash non-leaf
+  document: *foo-one-two
+  key: foo.1
+  
+  exists: true
+  value:
+    two: 2
+  expanded: false
+
+- name: array index - scalar leaf
+  document: *foo-one-two
+  key: bar.1
+  
+  exists: true
+  value: 4
+  expanded: false
+
+- name: array index - scalar leaf - missing
+  document: *foo-one-two
+  key: bar.2
+  
+  exists: false
+  value: ~
+  expanded: false
+
+- name: array index - scalar leaf - missing with further hash subscription
+  document: *foo-one-two
+  key: bar.2.any
+  
+  exists: false
+  value: ~
+  expanded: false
+
+- 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
+  
+  exists: true
+  value: [Steve]
+  expanded: true
+
+- name: non-sequential nested arrays - hash non-leaf - one value
+  document: *books-authors
+  key: books.0
+  
+  exists: true
+  value:
+    authors:
+      - name: Steve
+  expanded: false
+
+- name: non-sequential nested arrays - hash non-leaf - multiple values
+  document: *books-authors
+  key: books.1
+  
+  exists: true
+  value:
+    authors:
+      - name: Boris
+      - name: Pasha
+  expanded: false
+
+- name: sequential nested arrays - numerically indexed leaf
+  document: &groups
+    groups:
+      - [1]
+  key: groups.0.0
+  
+  exists: true
+  value: 1
+  expanded: false
+
+- name: sequential nested arrays - numerically indexed leaf - missing
+  document: *groups
+  key: groups.0.1
+  
+  exists: false
+  value: ~
+  expanded: false
+
+- name: sequential nested arrays - missing hash path through non-leaf
+  document: *groups
+  key: groups.missing
+  
+  exists: false
+  value: []
+  expanded: true
+
+- name: sequential nested arrays - missing hash path through leaf
+  document: *groups
+  key: groups.0.missing
+  
+  exists: false
+  value: []
+  expanded: true
+
+- name: sequential nested arrays - missing hash path past leaf
+  document: *groups
+  key: groups.0.0.missing
+  
+  exists: false
+  value: ~
+  expanded: false
+
+- name: mix of arrays and hashes in an array
+  document:
+    foo:
+      -
+        -
+          bar: 1
+      - bar: 2
+  key: foo.bar
+  
+  exists: true
+  value: [2]
+  expanded: true
+
+- name: numeric index through a primitive value not supporting subscription operator
+  document:
+    occupants:
+      -
+        age: 20
+  key:
+    occupants.0.age.0
+    
+  exists: false
+  value: ~
+  expanded: false

data/spec/mongoid/matcher/extract_attribute_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+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 = YAML.load(File.read(path))
+
+      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_exists) { spec['exists'] }
+          let(:expected_value) { spec['value'] }
+          let(:expected_expanded) { spec['expanded'] }
+
+          it 'has the expected exists flag' do
+            actual[0].should == expected_exists
+          end
+
+          it 'has the expected value' do
+            actual[1].should == expected_value
+          end
+
+          it 'has the expected expanded flag' do
+            actual[2].should == expected_expanded
+          end
+        end
+      end
+    end
+  end
+end

data/spec/mongoid/persistable/creatable_spec.rb

@@ -143,29 +143,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
 
@@ -207,7 +262,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
@@ -266,8 +321,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
@@ -343,17 +398,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
 

data/spec/mongoid/persistable/deletable_spec.rb

@@ -173,6 +173,92 @@ describe Mongoid::Persistable::Deletable do
         end
       end
     end
+
+    context "when deleting all documents with a custom discriminator key" do
+      before do
+        Canvas.discriminator_key = "dkey"
+      end
+
+      after do
+        Canvas.discriminator_key = nil
+      end
+
+      let!(:firefox) do
+        Firefox.create(name: "firefox")
+      end
+
+      let!(:firefox2) do
+        Firefox.create(name: "firefox 2")
+      end
+
+      let!(:browser) do
+        Browser.create(name: "browser")
+      end
+
+      let!(:canvas) do
+        Canvas.create(name: "canvas")
+      end
+
+      before do
+        Firefox.delete_all
+      end
+
+      it "deletes from the parent class collection" do
+        expect(Canvas.count).to eq(2)
+      end
+
+      it "returns correct counts for child classes" do
+        expect(Firefox.count).to eq(0)
+      end
+
+      it "returns correct counts for root subclasses" do
+        expect(Browser.count).to eq(1)
+      end
+    end
+
+    context "when deleting all documents with a custom discriminator value" do
+      before do
+        Canvas.discriminator_key = "dkey"
+        Firefox.discriminator_value = "dvalue"
+      end
+
+      after do
+        Canvas.discriminator_key = nil
+        Firefox.discriminator_value = nil
+      end
+
+      let!(:firefox) do
+        Firefox.create(name: "firefox")
+      end
+
+      let!(:firefox2) do
+        Firefox.create(name: "firefox 2")
+      end
+
+      let!(:browser) do
+        Browser.create(name: "browser")
+      end
+
+      let!(:canvas) do
+        Canvas.create(name: "canvas")
+      end
+
+      before do
+        Firefox.delete_all
+      end
+
+      it "deletes from the parent class collection" do
+        expect(Canvas.count).to eq(2)
+      end
+
+      it "returns correct counts for child classes" do
+        expect(Firefox.count).to eq(0)
+      end
+
+      it "returns correct counts for root subclasses" do
+        expect(Browser.count).to eq(1)
+      end
+    end
   end
 
   describe "#delete_all" do