mongoid 7.1.11 → 7.2.0

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