mongoid 7.0.13 → 8.0.8

data/spec/mongoid/extensions/time_with_zone_spec.rb

@@ -1,23 +1,17 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Mongoid::Extensions::TimeWithZone do
 
   describe ".demongoize" do
 
-    after(:all) do
-      Mongoid.use_utc = false
-      Mongoid.use_activesupport_time_zone = true
-    end
-
     let!(:time) do
       Time.local(2010, 11, 19)
     end
 
     context "when the time zone is not defined" do
-
-      before do
-        Mongoid.use_utc = false
-      end
+      config_override :use_utc, false
 
       context "when the local time is not observing daylight saving" do
 
@@ -55,15 +49,14 @@ describe Mongoid::Extensions::TimeWithZone do
       end
 
       context "when using the ActiveSupport time zone" do
+        config_override :use_activesupport_time_zone, true
 
         before do
-          Mongoid.use_activesupport_time_zone = true
           Time.zone = "Stockholm"
         end
 
         after do
           Time.zone = nil
-          Mongoid.use_activesupport_time_zone = false
         end
 
         it "returns an ActiveSupport::TimeWithZone" do
@@ -112,33 +105,25 @@ describe Mongoid::Extensions::TimeWithZone do
     end
 
     context "when the time zone is defined as UTC" do
-
-      before do
-        Mongoid.use_utc = true
-      end
-
-      after do
-        Mongoid.use_utc = false
-      end
+      config_override :use_utc, true
 
       it "returns utc" do
         expect(ActiveSupport::TimeWithZone.demongoize(time.dup.utc).utc_offset).to eq(0)
       end
 
       context "when using the ActiveSupport time zone" do
+        config_override :use_activesupport_time_zone, true
 
         let(:time) do
           Time.utc(2010, 11, 19, 0, 30)
         end
 
         before do
-          Mongoid.use_activesupport_time_zone = true
           Time.zone = "Stockholm"
         end
 
         after do
           Time.zone = nil
-          Mongoid.use_activesupport_time_zone = false
         end
 
         it "returns utc" do
@@ -178,8 +163,12 @@ describe Mongoid::Extensions::TimeWithZone do
 
     context "when string is empty" do
 
+      let(:mongoized) do
+        ActiveSupport::TimeWithZone.mongoize("")
+      end
+
       it "returns nil" do
-        expect(ActiveSupport::TimeWithZone.mongoize("")).to be_nil
+        expect(mongoized).to be_nil
       end
     end
 
@@ -203,23 +192,25 @@ describe Mongoid::Extensions::TimeWithZone do
       end
 
       context "when the string is an invalid time" do
+        let(:mongoized) do
+          ActiveSupport::TimeWithZone.mongoize("time")
+        end
 
         it "returns nil" do
-          expect(ActiveSupport::TimeWithZone.mongoize("time")).to eq(nil)
+          expect(mongoized).to be_nil
         end
       end
 
       context "when using the ActiveSupport time zone" do
+        config_override :use_activesupport_time_zone, true
 
         before do
-          Mongoid.use_activesupport_time_zone = true
           # if this is actually your time zone, the following tests are useless
           Time.zone = "Stockholm"
         end
 
         after do
           Time.zone = nil
-          Mongoid.use_activesupport_time_zone = false
         end
 
         context "when the local time is not observing daylight saving" do
@@ -255,20 +246,19 @@ describe Mongoid::Extensions::TimeWithZone do
       end
 
       context "when using the ActiveSupport time zone" do
+        config_override :use_activesupport_time_zone, true
 
         let(:datetime) do
           DateTime.new(2010, 11, 19)
         end
 
         before do
-          Mongoid.use_activesupport_time_zone = true
           # if this is actually your time zone, the following tests are useless
           Time.zone = "Stockholm"
         end
 
         after do
           Time.zone = nil
-          Mongoid.use_activesupport_time_zone = false
         end
 
         it "assumes the given time is local" do
@@ -326,20 +316,19 @@ describe Mongoid::Extensions::TimeWithZone do
       end
 
       context "when using the ActiveSupport time zone" do
+        config_override :use_activesupport_time_zone, true
 
         let(:date) do
           Date.new(2010, 11, 19)
         end
 
         before do
-          Mongoid.use_activesupport_time_zone = true
           # if this is actually your time zone, the following tests are useless
           Time.zone = "Stockholm"
         end
 
         after do
           Time.zone = nil
-          Mongoid.use_activesupport_time_zone = false
         end
 
         it "assumes the given time is local" do
@@ -359,16 +348,15 @@ describe Mongoid::Extensions::TimeWithZone do
       end
 
       context "when using the ActiveSupport time zone" do
+        config_override :use_activesupport_time_zone, true
 
         before do
-          Mongoid.use_activesupport_time_zone = true
           # if this is actually your time zone, the following tests are useless
           Time.zone = "Stockholm"
         end
 
         after do
           Time.zone = nil
-          Mongoid.use_activesupport_time_zone = false
         end
 
         it "assumes the given time is local" do
@@ -398,4 +386,35 @@ describe Mongoid::Extensions::TimeWithZone do
       expect(time.mongoize.to_f).to eq(time.to_f)
     end
   end
+
+  describe "__mongoize_time__" do
+
+    let(:time) do
+      ActiveSupport::TimeZone['Magadan'].at(1543331265.123457)
+    end
+
+    before do
+      expect(time).to be_a(ActiveSupport::TimeWithZone)
+    end
+
+    let(:mongoized) do
+      time.__mongoize_time__
+    end
+
+    let(:expected_time) { time.in_time_zone }
+
+    context "when using active support's time zone" do
+      include_context 'using AS time zone'
+
+      it_behaves_like 'mongoizes to AS::TimeWithZone'
+      it_behaves_like 'maintains precision when mongoized'
+    end
+
+    context "when not using active support's time zone" do
+      include_context 'not using AS time zone'
+
+      it_behaves_like 'mongoizes to AS::TimeWithZone'
+      it_behaves_like 'maintains precision when mongoized'
+    end
+  end
 end

data/spec/mongoid/extensions/true_class_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Mongoid::Extensions::TrueClass do
@@ -14,7 +16,7 @@ describe Mongoid::Extensions::TrueClass do
     context "when provided a Boolean" do
 
       it "returns true" do
-        expect(true.is_a?(Boolean)).to be true
+        expect(true.is_a?(Mongoid::Boolean)).to be true
       end
     end
 

data/spec/mongoid/extensions_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe BSON::ObjectId do
@@ -8,8 +10,20 @@ describe BSON::ObjectId do
       described_class.new
     end
 
-    it "returns the $oid plus string" do
-      expect(object_id.as_json).to eq("$oid" => object_id.to_s)
+    context "when object_id_as_json_oid is not set" do
+      config_override :object_id_as_json_oid, false
+
+      it "uses bson-ruby's implementation of as_json" do
+        expect(object_id.as_json).to eq(object_id.bson_ruby_as_json)
+      end
+    end
+
+    context "when object_id_as_json_oid is set" do
+      config_override :object_id_as_json_oid, true
+
+      it "returns the $oid plus string" do
+        expect(object_id.as_json).to eq("$oid" => object_id.to_s)
+      end
     end
   end
 end

data/spec/mongoid/factory_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Mongoid::Factory do
@@ -75,28 +77,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
@@ -106,15 +178,65 @@ 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
 
-      it "sets the attributes to empty" do
-        expect(document.attributes).to be_empty
+      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
+          skip 'https://jira.mongodb.org/browse/MONGOID-5179'
+          # Note that Address provides the _id override.
+          document.attributes.should == {'_type' => 'Address'}
+        end
+      end
+
+      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
 
@@ -176,39 +298,237 @@ describe Mongoid::Factory do
 
     context "when a type is not in the attributes" do
 
+      context "when using the default discriminator key" do
+        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
+
+      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
+
+      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
+
+    context 'when type does not correspond to a Class name' do
+
       let(:attributes) do
-        { "title" => "Sir" }
+        { "title" => "Sir", "_type" => "invalid_class_name" }
       end
 
-      let(:document) do
+      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 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(document).to be_a(Person)
+        expect(person).to be_a(Person)
       end
 
       it "sets the attributes" do
-        expect(document.title).to eq("Sir")
+        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 does not correspond to a Class name' do
+    context 'when type is correct but the instantiation raises a NoMethodError' do
+      class BadPerson < Person
+        def self.instantiate_document(*args)
+          call_some_nonexistent_method(*args)
+          super
+        end
+      end
 
       let(:attributes) do
-        { "title" => "Sir", "_type" => "invalid_class_name" }
+        { "title" => "Sir", "_type" => "BadPerson" }
       end
 
       let(:person) do
-        described_class.from_db(Person, attributes)
+        described_class.from_db(BadPerson, attributes)
       end
 
       it 'raises a exception' do
         expect {
           person
-        }.to raise_exception(Mongoid::Errors::UnknownModel)
+        }.to raise_exception(NoMethodError)
+      end
+
+    end
+
+    context "when not deferring callbacks" do
+
+      let(:person) do
+        described_class.execute_from_db(Person, {}, execute_callbacks: true)
+      end
+
+      before do
+        Person.set_callback :initialize, :after do |doc|
+          doc.title = "Madam"
+        end
+
+        Person.set_callback :find, :after do |doc|
+          doc.ssn = 1234
+        end
+      end
+
+      after do
+        Person.reset_callbacks(:initialize)
+        Person.reset_callbacks(:find)
+      end
+
+      it "runs the initialize callbacks" do
+        expect(person.title).to eq("Madam")
       end
 
+      it "runs the find callbacks" do
+        expect(person.ssn).to eq(1234)
+      end
+    end
+
+    context "when deferring callbacks" do
+
+      let(:person) do
+        described_class.execute_from_db(Person, {}, nil, nil, execute_callbacks: false)
+      end
+
+      before do
+        Person.set_callback :initialize, :after do |doc|
+          doc.title = "Madam"
+        end
+
+        Person.set_callback :find, :after do |doc|
+          doc.ssn = 1234
+        end
+      end
+
+      after do
+        Person.reset_callbacks(:initialize)
+        Person.reset_callbacks(:find)
+      end
+
+      it "runs the initialize callbacks" do
+        expect(person.title).to be nil
+      end
+
+      it "runs the find callbacks" do
+        expect(person.ssn).to be nil
+      end
     end
   end
 end

data/spec/mongoid/fields/foreign_key_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Mongoid::Fields::ForeignKey do