mongoid 7.0.5 → 8.1.5

data/spec/mongoid/extensions/date_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Mongoid::Extensions::Date do
@@ -5,21 +7,13 @@ describe Mongoid::Extensions::Date do
   describe "__mongoize_time__" do
 
     context "when using active support's time zone" do
-
-      before do
-        Mongoid.use_activesupport_time_zone = true
-        Time.zone = "Tokyo"
-      end
-
-      after do
-        Time.zone = nil
-      end
+      include_context 'using AS time zone'
 
       let(:date) do
         Date.new(2010, 1, 1)
       end
 
-      let(:expected) do
+      let(:expected_time) do
         Time.zone.local(2010, 1, 1, 0, 0, 0, 0)
       end
 
@@ -27,27 +21,17 @@ describe Mongoid::Extensions::Date do
         date.__mongoize_time__
       end
 
-      it "returns the date as a local time" do
-        expect(mongoized).to eq(expected)
-      end
+      it_behaves_like 'mongoizes to AS::TimeWithZone'
     end
 
     context "when not using active support's time zone" do
-
-      before do
-        Mongoid.use_activesupport_time_zone = false
-      end
-
-      after do
-        Mongoid.use_activesupport_time_zone = true
-        Time.zone = nil
-      end
+      include_context 'not using AS time zone'
 
       let(:date) do
         Date.new(2010, 1, 1)
       end
 
-      let(:expected) do
+      let(:expected_time) do
         Time.local(2010, 1, 1, 0, 0, 0, 0)
       end
 
@@ -55,9 +39,7 @@ describe Mongoid::Extensions::Date do
         date.__mongoize_time__
       end
 
-      it "returns the date as a local time" do
-        expect(mongoized).to eq(expected)
-      end
+      it_behaves_like 'mongoizes to Time'
     end
   end
 
@@ -72,160 +54,96 @@ describe Mongoid::Extensions::Date do
     end
 
     it "keeps the date" do
-      expect(Date.demongoize(time)).to eq(expected)
+      expect(Date.demongoize(expected)).to eq(expected)
+      expect(Date.demongoize(expected)).to be_a(Date)
     end
 
     it "converts to a date" do
+      expect(Date.demongoize(time)).to eq(expected)
       expect(Date.demongoize(time)).to be_a(Date)
     end
-  end
-
-  describe ".mongoize" do
-
-    context "when provided a date" do
-
-      let(:date) do
-        Date.new(2010, 1, 1)
-      end
 
-      let(:evolved) do
-        Date.mongoize(date)
-      end
-
-      let(:expected) do
-        Time.utc(2010, 1, 1, 0, 0, 0)
-      end
+    context "when demongoizing nil" do
 
-      it "returns the time" do
-        expect(evolved).to eq(expected)
+      it "returns nil" do
+        expect(Date.demongoize(nil)).to be_nil
       end
     end
 
-    context "when provided a string" do
-
-      context "when the string is a valid date" do
-
-        let(:date) do
-          Date.parse("1st Jan 2010")
-        end
-
-        let(:evolved) do
-          Date.mongoize(date.to_s)
-        end
-
-        let(:expected) do
-          Time.utc(2010, 1, 1, 0, 0, 0, 0)
-        end
-
-        it "returns the string as a time" do
-          expect(evolved).to eq(expected)
-        end
-      end
-
-      context "when the string is empty" do
+    context "when demongoizing a bogus value" do
 
-        let(:evolved) do
-          Date.mongoize("")
-        end
-
-        it "returns nil" do
-          expect(evolved).to be_nil
-        end
-      end
-
-      context "when the string is an invalid time" do
-
-        it "returns nil" do
-          expect(Date.mongoize("time")).to eq(nil)
-        end
+      it "returns nil" do
+        expect(Date.demongoize("bogus")).to be_nil
       end
     end
 
-    context "when provided a float" do
+    context "when demongoizing a string" do
 
-      let(:time) do
-        Time.utc(2010, 1, 1, 1, 0, 0, 0)
-      end
+      let(:date) { "2022-07-11 14:03:42 -0400" }
 
-      let(:float) do
-        time.to_f
+      it "returns a date" do
+        expect(Date.demongoize(date)).to eq(date.to_date)
       end
+    end
+  end
 
-      let(:evolved) do
-        Date.mongoize(float)
-      end
+  describe "#mongoize" do
 
-      let(:expected) do
-        Time.at(float)
-      end
+    let(:date) do
+      Date.new(2010, 1, 1)
+    end
 
-      it "returns the float as a time" do
-        expect(evolved).to eq(Time.utc(expected.year, expected.month, expected.day))
-      end
+    let(:time) do
+      Time.utc(2010, 1, 1, 0, 0, 0, 0)
     end
 
-    context "when provided an integer" do
+    it "returns the date as a time at midnight" do
+      expect(date.mongoize).to eq(time)
+    end
+  end
 
-      let(:time) do
-        Time.utc(2010, 1, 1, 0, 0, 0, 0)
-      end
+  describe ".mongoize" do
+    let(:date) do
+      Date.new(2010, 1, 1)
+    end
 
-      let(:integer) do
-        time.to_i
-      end
+    let(:time) do
+      Time.utc(2010, 1, 1, 0, 0, 0, 0)
+    end
 
-      let(:evolved) do
-        Date.mongoize(integer)
-      end
+    let(:datetime) do
+      time.to_datetime
+    end
 
-      let(:expected) do
-        Time.at(integer)
-      end
+    context "when the value is a date" do
 
-      it "returns the integer as a time" do
-        expect(evolved).to eq(Time.utc(expected.year, expected.month, expected.day))
+      it "converts to a date" do
+        expect(Date.mongoize(date)).to eq(date)
+        expect(Date.mongoize(date)).to be_a(Time)
       end
     end
 
-    context "when provided an array" do
-
-      let(:time) do
-        Time.utc(2010, 1, 1, 0, 0, 0, 0)
-      end
+    context "when the value is a time" do
 
-      let(:array) do
-        [ 2010, 1, 1, 0, 0, 0, 0 ]
+      it "keeps the time" do
+        expect(Date.mongoize(time)).to eq(date)
+        expect(Date.mongoize(time)).to be_a(Time)
       end
+    end
 
-      let(:evolved) do
-        Date.mongoize(array)
-      end
+    context "when the value is a datetime" do
 
-      it "returns the array as a time" do
-        expect(evolved).to eq(time)
+      it "converts to a time" do
+        expect(Date.mongoize(datetime)).to eq(date)
+        expect(Date.mongoize(datetime)).to be_a(Time)
       end
     end
 
-    context "when provided nil" do
+    context "when the value is uncastable" do
 
       it "returns nil" do
-        expect(Date.mongoize(nil)).to be_nil
+        expect(Date.mongoize("bogus")).to be_nil
       end
     end
   end
-
-  describe "#mongoize" do
-
-    let(:date) do
-      Date.new(2010, 1, 1)
-    end
-
-    let(:time) do
-      Time.utc(2010, 1, 1, 0, 0, 0, 0)
-    end
-
-    it "returns the date as a time at midnight" do
-      expect(date.mongoize).to eq(time)
-    end
-  end
 end

data/spec/mongoid/extensions/date_time_spec.rb

@@ -1,78 +1,35 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Mongoid::Extensions::DateTime do
 
   describe "__mongoize_time__" do
 
-    context "when the date time has more than seconds precision" do
-
-      let(:date_time) do
-        DateTime.parse("2012-06-17 18:42:15.123Z")
-      end
-
-      let(:mongoized) do
-        date_time.__mongoize_time__
-      end
-
-      it "does not drop the precision" do
-        expect(mongoized.to_f.to_s).to match(/\.123/)
-      end
+    let(:date_time) do
+      # DateTime has time zone information, even if a time zone is not provided
+      # when parsing a string
+      DateTime.parse("2012-06-17 18:42:15.123457")
     end
 
-    context "when using active support's time zone" do
-
-      before do
-        Mongoid.use_activesupport_time_zone = true
-        Time.zone = "Tokyo"
-      end
-
-      after do
-        Time.zone = nil
-      end
-
-      let(:date_time) do
-        DateTime.new(2010, 1, 1)
-      end
+    let(:mongoized) do
+      date_time.__mongoize_time__
+    end
 
-      let(:expected) do
-        Time.zone.local(2010, 1, 1, 9, 0, 0, 0)
-      end
+    let(:expected_time) { date_time.to_time.in_time_zone }
 
-      let(:mongoized) do
-        date_time.__mongoize_time__
-      end
+    context "when using active support's time zone" do
+      include_context 'using AS time zone'
 
-      it "returns the date as a local time" do
-        expect(mongoized).to eq(expected)
-      end
+      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'
 
-      before do
-        Mongoid.use_activesupport_time_zone = false
-      end
-
-      after do
-        Mongoid.use_activesupport_time_zone = true
-        Time.zone = nil
-      end
-
-      let(:date_time) do
-        DateTime.new(2010, 1, 1)
-      end
-
-      let(:expected) do
-        Time.utc(2010, 1, 1, 0, 0, 0, 0).getlocal
-      end
-
-      let(:mongoized) do
-        date_time.__mongoize_time__
-      end
-
-      it "returns the date as a utc time" do
-        expect(mongoized).to eq(expected)
-      end
+      it_behaves_like 'mongoizes to Time'
+      it_behaves_like 'maintains precision when mongoized'
     end
   end
 
@@ -95,14 +52,7 @@ describe Mongoid::Extensions::DateTime do
     end
 
     context "when using utc" do
-
-      before do
-        Mongoid.use_utc = true
-      end
-
-      after do
-        Mongoid.use_utc = false
-      end
+      config_override :use_utc, true
 
       context "when setting a utc time" do
 
@@ -123,14 +73,27 @@ describe Mongoid::Extensions::DateTime do
         end
       end
     end
+
+    context "when demongoizing a string" do
+
+      let(:date) { "2022-07-11 14:03:42 -0400" }
+
+      it "returns a date" do
+        expect(DateTime.demongoize(date)).to eq(date.to_datetime)
+      end
+    end
   end
 
   describe ".mongoize" do
 
     context "when the string is an invalid time" do
 
+      let(:mongoized) do
+        DateTime.mongoize("time")
+      end
+
       it "returns nil" do
-        expect(DateTime.mongoize("time")).to eq(nil)
+        expect(mongoized).to be_nil
       end
     end
   end

data/spec/mongoid/extensions/decimal128_spec.rb

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

data/spec/mongoid/extensions/false_class_spec.rb

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

data/spec/mongoid/extensions/float_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Mongoid::Extensions::Float do
@@ -9,130 +11,121 @@ describe Mongoid::Extensions::Float do
   describe "#__mongoize_time__" do
 
     let(:float) do
-      1335532685.117847
+      1335532685.123457
     end
 
     let(:mongoized) do
       float.__mongoize_time__
     end
 
-    it "returns the float as a time" do
-      expect(mongoized).to eq(Time.at(float))
-    end
-  end
+    let(:expected_time) { Time.at(float).in_time_zone }
 
-  describe ".demongoize" do
+    context "when using active support's time zone" do
+      include_context 'using AS time zone'
 
-    context "when the value is a float" do
-
-      it "returns a float" do
-        expect(Float.demongoize(number)).to eq(number)
-      end
+      it_behaves_like 'mongoizes to AS::TimeWithZone'
+      it_behaves_like 'maintains precision when mongoized'
     end
 
-    context "when the value is nil" do
+    context "when not using active support's time zone" do
+      include_context 'not using AS time zone'
 
-      it "returns nil" do
-        expect(Float.demongoize(nil)).to be_nil
-      end
-    end
-
-    context "when the value is a float string" do
-
-      it "returns a float" do
-        expect(Float.demongoize(number.to_s)).to eq(number)
-      end
+      it_behaves_like 'mongoizes to Time'
+      it_behaves_like 'maintains precision when mongoized'
     end
+  end
 
-    context "when the value is not a float string" do
+  [ :mongoize, :demongoize ].each do |method|
 
-      it "returns a float" do
-        expect(Float.demongoize('asdf')).to eq(0)
-      end
-    end
-  end
+    describe ".#{method}" do
 
-  describe ".mongoize" do
+      context "when the value is a number" do
 
-    context "when the value is a number" do
+        context "when the value is an float" do
 
-      context "when the value is an float" do
+          context "when the value is small" do
 
-        context "when the value is small" do
+            it "it returns the float" do
+              expect(Float.send(method, 3)).to eq(3)
+            end
 
-          it "it returns the float" do
-            expect(Float.mongoize(3)).to eq(3)
+            it "returns the number as type float" do
+              expect(Float.send(method, 3)).to be_a(Float)
+            end
           end
 
-          it "returns the number as type float" do
-            expect(Float.mongoize(3)).to be_a(Float)
+          context "when the value is large" do
+
+            it "returns the float" do
+              expect(Float.send(method, 1024**2).to_s).to eq("1048576.0")
+            end
           end
         end
 
-        context "when the value is large" do
+        context "when the value is a decimal" do
 
-          it "returns the float" do
-            expect(Float.mongoize(1024**2).to_s).to eq("1048576.0")
+          it "casts to float" do
+            expect(Float.send(method, 2.5)).to eq(2.5)
           end
         end
-      end
 
-      context "when the value is a decimal" do
+        context "when the value is floating point zero" do
 
-        it "casts to float" do
-          expect(Float.mongoize(2.5)).to eq(2.5)
+          it "returns the float zero" do
+            expect(Float.send(method, 0.00000)).to eq(0)
+          end
         end
-      end
 
-      context "when the value is floating point zero" do
+        context "when the value is a floating point float" do
 
-        it "returns the float zero" do
-          expect(Float.mongoize(0.00000)).to eq(0)
+          it "returns the float number" do
+            expect(Float.send(method, 4.00000)).to eq(4)
+          end
         end
-      end
 
-      context "when the value is a floating point float" do
+        context "when the value has leading zeros" do
 
-        it "returns the float number" do
-          expect(Float.mongoize(4.00000)).to eq(4)
+          it "returns the stripped float" do
+            expect(Float.send(method, "000011")).to eq(11)
+          end
         end
       end
 
-      context "when the value has leading zeros" do
+      context "when the string is not a number" do
 
-        it "returns the stripped float" do
-          expect(Float.mongoize("000011")).to eq(11)
-        end
-      end
-    end
+        context "when the string is non numerical" do
 
-    context "when the string is not a number" do
+          it "returns nil" do
+            expect(Float.send(method, "foo")).to be_nil
+          end
+        end
 
-      context "when the string is non numerical" do
+        context "when the string starts with a number" do
 
-        it "returns 0" do
-          expect(Float.mongoize("foo")).to eq(0.0)
+          it "returns nil" do
+            expect(Float.send(method, "42bogus")).to be_nil
+          end
         end
-      end
 
-      context "when the string is numerical" do
+        context "when the string is empty" do
 
-        it "returns the float value for the string" do
-          expect(Float.mongoize("3")).to eq(3)
+          it "returns nil" do
+            expect(Float.send(method, "")).to be_nil
+          end
         end
-      end
 
-      context "when the string is empty" do
+        context "when the string is nil" do
 
-        it "returns nil" do
-          expect(Float.mongoize("")).to be_nil
+          it "returns nil" do
+            expect(Float.send(method, nil)).to be_nil
+          end
         end
-      end
 
-      context "when the string is nil" do
+        context "when giving an object that is castable to an Float" do
 
-        it "returns nil" do
-          expect(Float.mongoize(nil)).to be_nil
+          it "returns the integer value" do
+            expect(Float.send(method, 2.hours)).to eq(7200)
+          end
         end
       end
     end