mongoid 7.1.5 → 7.2.1

data/spec/mongoid/extensions/stringified_symbol_spec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Mongoid::StringifiedSymbol do
+
+  describe ".demongoize" do
+
+    context "when the object is not a symbol" do
+
+      it "returns the symbol" do
+        expect(Mongoid::StringifiedSymbol.demongoize("test")).to eq(:test)
+      end
+    end
+
+    context "when the object is a symbol" do
+
+      it "returns the symbol" do
+        expect(Mongoid::StringifiedSymbol.demongoize(:test)).to eq(:test)
+      end
+    end
+
+    context "when the object is a BSON Symbol" do
+
+      it "returns a symbol" do
+        expect(Mongoid::StringifiedSymbol.demongoize(BSON::Symbol::Raw.new(:test))).to eq(:test)
+      end
+    end
+
+
+    context "when the object is an integer" do
+
+      it "returns a symbol" do
+        expect(Mongoid::StringifiedSymbol.demongoize(14)).to eq(:"14")
+      end
+    end
+
+    context "when the object is nil" do
+
+      it "returns nil" do
+        expect(Mongoid::StringifiedSymbol.demongoize(nil)).to be_nil
+      end
+    end
+  end
+
+  describe ".mongoize" do
+
+    context "when the object is not a symbol" do
+
+      it "returns the object" do
+        expect(Mongoid::StringifiedSymbol.mongoize("test")).to eq("test")
+      end
+
+      it "returns the string" do
+        expect(Mongoid::StringifiedSymbol.mongoize([0,1,2])).to eq("[0, 1, 2]")
+      end
+
+      it "returns the string" do
+        expect(Mongoid::StringifiedSymbol.mongoize(2)).to eq("2")
+      end
+    end
+
+    context "when the object is a symbol" do
+
+      it "returns a string" do
+        expect(Mongoid::StringifiedSymbol.mongoize(:test)).to eq("test")
+      end
+    end
+
+    context "when the object is nil" do
+
+      it "returns nil" do
+        expect(Mongoid::StringifiedSymbol.mongoize(nil)).to be_nil
+      end
+    end
+  end
+
+  describe "#mongoize" do
+
+    it "returns self" do
+      expect(:test.mongoize).to eq(:test)
+    end
+  end
+end

data/spec/mongoid/factory_spec.rb

@@ -78,28 +78,98 @@ describe Mongoid::Factory do
     end
 
     context "when type is not preset" do
+      context "when using the default discriminator key" do
+        let(:attributes) do
+          { "title" => "Sir" }
+        end
 
-      let(:attributes) do
-        { "title" => "Sir" }
-      end
+        let(:person) do
+          described_class.build(Person, attributes)
+        end
 
-      let(:person) do
-        described_class.build(Person, attributes)
-      end
+        it "instantiates based on the provided class" do
+          expect(person.title).to eq("Sir")
+        end
 
-      it "instantiates based on the provided class" do
-        expect(person.title).to eq("Sir")
+        context "when the type is a symbol" do
+
+          let(:person) do
+            described_class.build(Person, { :_type => "Doctor" })
+          end
+
+          it "instantiates the subclass" do
+            expect(person.class).to eq(Doctor)
+          end
+        end
       end
-    end
 
-    context "when the type is a symbol" do
+      context "when using a custom discriminator key" do
+        before do
+          Person.discriminator_key = "dkey"
+        end
 
-      let(:person) do
-        described_class.build(Person, { :_type => "Doctor" })
+        after do
+          Person.discriminator_key = nil
+        end
+
+        let(:attributes) do
+          { "title" => "Sir" }
+        end
+
+        let(:person) do
+          described_class.build(Person, attributes)
+        end
+
+        it "instantiates based on the provided class" do
+          expect(person.title).to eq("Sir")
+        end
+
+        context "when the type is a symbol" do
+
+          let(:person) do
+            described_class.build(Person, { :dkey => "Doctor" })
+          end
+
+          it "instantiates the subclass" do
+            expect(person.class).to eq(Doctor)
+          end
+        end
       end
 
-      it "instantiates the subclass" do
-        expect(person.class).to eq(Doctor)
+      context "when using a custom discriminator key and value" do
+        before do
+          Person.discriminator_key = "dkey"
+          Doctor.discriminator_value = "dvalue"
+        end
+
+        after do
+          Person.discriminator_key = nil
+          Doctor.discriminator_value = nil
+        end
+
+        let(:attributes) do
+          { "title" => "Sir", "dkey" => "dvalue" }
+        end
+
+        let(:doctor) do
+          described_class.build(Person, attributes)
+        end
+
+        it "instantiates based on the provided class" do
+          expect(doctor.title).to eq("Sir")
+        end
+
+        it "generates based on the provided class" do
+          expect(doctor).to be_a(Person)
+        end
+
+        it "sets the attributes" do
+          expect(doctor.title).to eq("Sir")
+        end
+
+        it "has the correct discriminator key/value" do
+          expect(doctor.dkey).to eq("dvalue")
+        end
       end
     end
   end
@@ -109,15 +179,64 @@ describe Mongoid::Factory do
     context "when the attributes are nil" do
 
       let(:document) do
-        described_class.from_db(Address, nil)
+        described_class.from_db(model_cls, nil)
       end
 
-      it "generates based on the provided class" do
-        expect(document).to be_a(Address)
+      context 'when model class does not use inheritance' do
+        context 'when model overwrites _id field to not have a default' do
+          let(:model_cls) { Idnodef }
+
+          it "generates based on the provided class" do
+            expect(document).to be_a(model_cls)
+          end
+
+          it "sets the attributes to empty" do
+            expect(document.attributes).to be_empty
+          end
+        end
+
+        context 'with default _id auto-assignment behavior' do
+          let(:model_cls) { Agency }
+
+          it "generates based on the provided class" do
+            expect(document).to be_a(model_cls)
+          end
+
+          it "sets the attributes to generated _id only" do
+            document.attributes.should == {'_id' => document.id}
+          end
+        end
+      end
+
+      context 'when model class is an inheritance root' do
+        let(:model_cls) { Address }
+
+        before do
+          # Ensure a child is defined
+          ShipmentAddress.superclass.should be model_cls
+        end
+
+        it "generates based on the provided class" do
+          expect(document).to be_a(model_cls)
+        end
+
+        it "sets the attributes to _type only" do
+          # Note that Address provides the _id override.
+          document.attributes.should == {'_type' => 'Address'}
+        end
       end
 
-      it "sets the attributes to empty" do
-        expect(document.attributes).to be_empty
+      context 'when model class is an inheritance leaf' do
+        let(:model_cls) { ShipmentAddress }
+
+        it "generates based on the provided class" do
+          expect(document).to be_a(model_cls)
+        end
+
+        it "sets the attributes to empty" do
+          # Note that Address provides the _id override.
+          document.attributes.should == {'_type' => 'ShipmentAddress'}
+        end
       end
     end
 
@@ -179,20 +298,80 @@ describe Mongoid::Factory do
 
     context "when a type is not in the attributes" do
 
-      let(:attributes) do
-        { "title" => "Sir" }
-      end
+      context "when using the default discriminator key" do
+        let(:attributes) do
+          { "title" => "Sir" }
+        end
 
-      let(:document) do
-        described_class.from_db(Person, attributes)
+        let(:document) do
+          described_class.from_db(Person, attributes)
+        end
+
+        it "generates based on the provided class" do
+          expect(document).to be_a(Person)
+        end
+
+        it "sets the attributes" do
+          expect(document.title).to eq("Sir")
+        end
       end
 
-      it "generates based on the provided class" do
-        expect(document).to be_a(Person)
+      context "when using a custom discriminator key" do
+        before do
+          Person.discriminator_key = "dkey"
+        end
+
+        after do
+          Person.discriminator_key = nil
+        end
+
+        let(:attributes) do
+          { "title" => "Sir" }
+        end
+
+        let(:document) do
+          described_class.from_db(Person, attributes)
+        end
+
+        it "generates based on the provided class" do
+          expect(document).to be_a(Person)
+        end
+
+        it "sets the attributes" do
+          expect(document.title).to eq("Sir")
+        end
       end
 
-      it "sets the attributes" do
-        expect(document.title).to eq("Sir")
+      context "when using a custom discriminator key and discriminator value" do
+        before do
+          Person.discriminator_key = "dkey"
+          Person.discriminator_value = "dvalue"
+        end
+
+        after do
+          Person.discriminator_key = nil
+          Person.discriminator_value = nil
+        end
+
+        let(:attributes) do
+          { "title" => "Sir" }
+        end
+
+        let(:document) do
+          described_class.from_db(Person, attributes)
+        end
+
+        it "generates based on the provided class" do
+          expect(document).to be_a(Person)
+        end
+
+        it "sets the attributes" do
+          expect(document.title).to eq("Sir")
+        end
+
+        it "has the correct discriminator key/value" do
+          expect(document.dkey).to eq("dvalue")
+        end
       end
     end
 
@@ -211,7 +390,61 @@ describe Mongoid::Factory do
           person
         }.to raise_exception(Mongoid::Errors::UnknownModel)
       end
+    end
+
+    context 'when type does not correspond to a Class name with custom discriminator key' do
+
+      before do
+        Person.discriminator_key = "dkey"
+      end
+
+      after do
+        Person.discriminator_key = nil
+      end
+
+      let(:attributes) do
+        { "title" => "Sir", "dkey" => "invalid_class_name" }
+      end
+
+      let(:person) do
+        described_class.from_db(Person, attributes)
+      end
+
+      it 'raises a exception' do
+        expect {
+          person
+        }.to raise_exception(Mongoid::Errors::UnknownModel)
+      end
+    end
+
+    context 'when type does not correspond to a custom discriminator_value' do
+      before do
+        Person.discriminator_value = "dvalue"
+      end
+
+      after do
+        Person.discriminator_value = nil
+      end
 
+      let(:attributes) do
+        { "title" => "Sir", "_type" => "dvalue" }
+      end
+
+      let(:person) do
+        described_class.from_db(Person, attributes)
+      end
+
+      it "generates based on the provided class" do
+        expect(person).to be_a(Person)
+      end
+
+      it "sets the attributes" do
+        expect(person.title).to eq("Sir")
+      end
+
+      it "has the correct discriminator key/value" do
+        expect(person._type).to eq("dvalue")
+      end
     end
 
     context 'when type is correct but the instantiation raises a NoMethodError' do

data/spec/mongoid/fields_spec.rb

@@ -833,7 +833,8 @@ describe Mongoid::Fields do
       end
 
       it "does not return subclass defaults" do
-        expect(shape.pre_processed_defaults).to eq([ "_id", "x", "y", "_type" ])
+        expect(shape.pre_processed_defaults).to eq([ "_id", "x", "y" ])
+        expect(shape.post_processed_defaults).to eq([ "_type" ])
       end
     end
 
@@ -844,7 +845,8 @@ describe Mongoid::Fields do
       end
 
       it "has the parent and child defaults" do
-        expect(circle.pre_processed_defaults).to eq([ "_id", "x", "y", "_type", "radius" ])
+        expect(circle.pre_processed_defaults).to eq([ "_id", "x", "y", "radius" ])
+        expect(circle.post_processed_defaults).to eq([ "_type" ])
       end
     end
   end
@@ -1116,6 +1118,10 @@ describe Mongoid::Fields do
       it "does not return subclass fields" do
         expect(shape.fields.keys).to_not include("radius")
       end
+
+      it 'includes _type field' do
+        expect(shape.fields.keys).to include("_type")
+      end
     end
 
     context "on subclasses" do
@@ -1135,6 +1141,28 @@ describe Mongoid::Fields do
       it "includes the child fields" do
         expect(circle.fields.keys).to include("radius")
       end
+
+      it 'includes _type field' do
+        expect(circle.fields.keys).to include("_type")
+      end
+    end
+
+    context "on new subclasses" do
+      it "all subclasses get the discriminator key" do
+        class DiscriminatorParent
+          include Mongoid::Document
+        end
+
+        class DiscriminatorChild1 < DiscriminatorParent
+        end
+
+        class DiscriminatorChild2 < DiscriminatorParent
+        end
+
+        expect(DiscriminatorParent.fields.keys).to include("_type")
+        expect(DiscriminatorChild1.fields.keys).to include("_type")
+        expect(DiscriminatorChild2.fields.keys).to include("_type")
+      end
     end
   end
 
@@ -1352,4 +1380,22 @@ describe Mongoid::Fields do
       end
     end
   end
+
+  describe '_type field' do
+    context 'on parent class' do
+      let(:shape) { Shape.new }
+
+      it 'is correctly set' do
+        shape.attributes['_type'].should == 'Shape'
+      end
+    end
+
+    context 'on child class' do
+      let(:circle) { Circle.new }
+
+      it 'is correctly set' do
+        circle.attributes['_type'].should == 'Circle'
+      end
+    end
+  end
 end