mongoid 7.1.7 → 7.2.0.rc1

data/spec/mongoid/document_spec.rb

@@ -116,7 +116,50 @@ describe Mongoid::Document do
       end
 
       it "should clear descendants' cache" do
-        expect(Person._types).to include(descendant.to_s)
+        expect(Person._types).to include(descendant.discriminator_value)
+      end
+    end
+  end
+
+  describe "._mongoid_clear_types" do
+
+    context "when changing the discriminator_value" do
+      
+      before do 
+        Kangaroo._types
+        Kangaroo.discriminator_value = "dvalue"
+      end
+
+      after do 
+        Kangaroo.discriminator_value = nil
+      end
+
+      it "has the correct _types" do
+        expect(Kangaroo._types).to eq(["dvalue"])
+      end
+    end
+
+    context "when changing the discriminator_value in child" do
+      
+      before do 
+        Shape._types
+        Circle.discriminator_value = "dvalue"
+      end
+
+      after do 
+        Circle.discriminator_value = nil
+      end
+
+      it "has the correct _types" do
+        expect(Circle._types).to eq(["dvalue"])
+      end
+
+      it "has the new Circle discriminator value" do
+        expect(Shape._types).to include("dvalue")
+      end
+
+      it "doesn't have the old Circle discriminator value" do
+        expect(Shape._types).to_not include("Cirlce")
       end
     end
   end
@@ -881,27 +924,58 @@ describe Mongoid::Document do
       end
 
       context "when no embedded documents are present" do
+        context "when using the default discriminator key" do 
+          let(:person) do
+            manager.becomes(Person)
+          end
 
-        let(:person) do
-          manager.becomes(Person)
-        end
+          it "copies attributes" do
+            expect(person.title).to eq('Sir')
+          end
 
-        it "copies attributes" do
-          expect(person.title).to eq('Sir')
-        end
+          it "keeps the same object id" do
+            expect(person.id).to eq(manager.id)
+          end
 
-        it "keeps the same object id" do
-          expect(person.id).to eq(manager.id)
+          it "sets the class type" do
+            expect(person._type).to eq("Person")
+          end
+
+          it "raises an error when inappropriate class is provided" do
+            expect {
+              manager.becomes(String)
+            }.to raise_error(ArgumentError, /A class which includes Mongoid::Document is expected/)
+          end
         end
 
-        it "sets the class type" do
-          expect(person._type).to eq("Person")
+        context "when using a custom discriminator key" do 
+          before do 
+            Person.discriminator_key = "dkey"
+          end
+
+          after do 
+            Person.discriminator_key = nil
+          end
+
+          it "sets the class type with new discriminator key" do
+            expect(person.dkey).to eq("Person")
+          end
         end
 
-        it "raises an error when inappropriate class is provided" do
-          expect {
-            manager.becomes(String)
-          }.to raise_error(ArgumentError)
+        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
+
+          it "sets the class type with new discriminator key" do
+            expect(person.dkey).to eq("dvalue")
+          end
         end
       end
 

data/spec/mongoid/errors/delete_restriction_spec.rb

@@ -19,7 +19,7 @@ describe Mongoid::Errors::DeleteRestriction do
 
     it "contains the summary in the message" do
       expect(error.message).to include(
-        "When defining 'drugs' with a :dependent => :restrict,"
+        "When defining 'drugs' with a :dependent => :restrict_with_error,"
       )
     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