mongoid 7.1.8 → 7.2.3

data/spec/mongoid/document_fields_spec.rb

@@ -85,4 +85,30 @@ describe Mongoid::Document do
       end
     end
   end
+
+  context 'Regexp field' do
+    shared_examples "persists strings as regexp" do |type|
+      it 'persists strings as regexp' do
+        mop = Mop.create!(regexp_field: 'foo')
+        expect(mop.regexp_field).to be_a Regexp
+        expect(Mop.find(mop.id).regexp_field).to be_a BSON::Regexp::Raw
+        expect(
+          Mop.collection.find(
+            "_id" => mop.id,
+            "regexp_field" => { "$type" => type }
+          ).count
+        ).to be == 1
+      end
+    end
+
+    context "< 3.2" do
+      max_server_version("3.1")
+      include_examples "persists strings as regexp", 11
+    end
+
+    context ">= 3.2" do
+      min_server_version("3.2")
+      it_behaves_like "persists strings as regexp", "regex"
+    end
+  end
 end

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/equality_spec.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 # encoding: utf-8
 
-# -*- coding: utf-8 -*-
 require "spec_helper"
 
 describe Mongoid::Equality do

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/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(Animal, nil)
+        described_class.from_db(model_cls, nil)
       end
 
-      it "generates based on the provided class" do
-        expect(document).to be_a(Animal)
+      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