mongoid 7.5.4 → 8.0.1

data/spec/mongoid/extensions/binary_spec.rb

@@ -15,18 +15,53 @@ describe BSON::Binary do
     end
   end
 
-  describe ".demongoize" do
 
-    let(:binary) do
-      BSON::Binary.new("testing", :md5)
-    end
+  [ :mongoize, :demongoize].each do |method|
+    describe ".#{method}" do
 
-    let(:demongoized) do
-      BSON::Binary.demongoize(binary)
-    end
+      let(:binary) do
+        BSON::Binary.new("testing")
+      end
 
-    it "returns the binary" do
-      expect(demongoized).to eq(binary)
+      let(:evaluated) do
+        BSON::Binary.send(method, value)
+      end
+
+      context "when mongoizing a BSON::Binary" do
+
+        let(:value) { binary }
+
+        it "returns the binary" do
+          expect(evaluated).to eq(binary)
+        end
+      end
+
+      context "when mongoizing a String" do
+
+        let(:value) { "testing" }
+
+        it "returns it as binary" do
+          expect(evaluated).to eq(binary)
+        end
+      end
+
+      context "when mongoizing nil" do
+
+        let(:value) { nil }
+
+        it "returns nil" do
+          expect(evaluated).to eq(nil)
+        end
+      end
+
+      context "when mongoizing an invalid type" do
+
+        let(:value) { true }
+
+        it "returns nil" do
+          expect(evaluated).to be_nil
+        end
+      end
     end
   end
 

data/spec/mongoid/extensions/boolean_spec.rb

@@ -4,139 +4,125 @@ require "spec_helper"
 
 describe Mongoid::Boolean do
 
-  describe ".demongoize" do
+  [ :mongoize, :demongoize ].each do |method|
 
-    context "when provided true" do
+    describe ".#{method}" do
 
-      it "returns true" do
-        expect(described_class.demongoize(true)).to eq(true)
-      end
-    end
-
-    context "when provided false" do
-
-      it "returns false" do
-        expect(described_class.demongoize(false)).to eq(false)
-      end
-    end
-  end
-
-  describe ".mongoize" do
-
-    context "when provided a boolean" do
+      context "when provided a boolean" do
 
-      context "when provided true" do
+        context "when provided true" do
 
-        it "returns true" do
-          expect(described_class.mongoize(true)).to eq(true)
+          it "returns true" do
+            expect(described_class.send(method, true)).to eq(true)
+          end
         end
-      end
 
-      context "when provided false" do
+        context "when provided false" do
 
-        it "returns false" do
-          expect(described_class.mongoize(false)).to eq(false)
+          it "returns false" do
+            expect(described_class.send(method, false)).to eq(false)
+          end
         end
       end
-    end
 
-    context "when provided a string" do
+      context "when provided a string" do
 
-      context "when provided true" do
+        context "when provided true" do
 
-        it "returns true" do
-          expect(described_class.mongoize("true")).to eq(true)
+          it "returns true" do
+            expect(described_class.send(method, "true")).to eq(true)
+          end
         end
-      end
 
-      context "when provided t" do
+        context "when provided t" do
 
-        it "returns true" do
-          expect(described_class.mongoize("t")).to eq(true)
+          it "returns true" do
+            expect(described_class.send(method, "t")).to eq(true)
+          end
         end
-      end
 
-      context "when provided 1" do
+        context "when provided 1" do
 
-        it "returns true" do
-          expect(described_class.mongoize("1")).to eq(true)
+          it "returns true" do
+            expect(described_class.send(method, "1")).to eq(true)
+          end
         end
-      end
 
-      context "when provided 1.0" do
+        context "when provided 1.0" do
 
-        it "returns true" do
-          expect(described_class.mongoize("1.0")).to eq(true)
+          it "returns true" do
+            expect(described_class.send(method, "1.0")).to eq(true)
+          end
         end
-      end
 
-      context "when provided yes" do
+        context "when provided yes" do
 
-        it "returns true" do
-          expect(described_class.mongoize("yes")).to eq(true)
+          it "returns true" do
+            expect(described_class.send(method, "yes")).to eq(true)
+          end
         end
-      end
 
-      context "when provided y" do
+        context "when provided y" do
 
-        it "returns true" do
-          expect(described_class.mongoize("y")).to eq(true)
+          it "returns true" do
+            expect(described_class.send(method, "y")).to eq(true)
+          end
         end
-      end
 
-      context "when provided on" do
+        context "when provided on" do
 
-        it "returns true" do
-          expect(described_class.mongoize("on")).to eq(true)
+          it "returns true" do
+            expect(described_class.send(method, "on")).to eq(true)
+          end
         end
-      end
 
-      context "when provided false" do
+        context "when provided false" do
 
-        it "returns false" do
-          expect(described_class.mongoize("false")).to eq(false)
+          it "returns false" do
+            expect(described_class.send(method, "false")).to eq(false)
+          end
         end
-      end
 
-      context "when provided f" do
+        context "when provided f" do
 
-        it "returns false" do
-          expect(described_class.mongoize("f")).to eq(false)
+          it "returns false" do
+            expect(described_class.send(method, "f")).to eq(false)
+          end
         end
-      end
 
-      context "when provided 0" do
+        context "when provided 0" do
 
-        it "returns false" do
-          expect(described_class.mongoize("0")).to eq(false)
+          it "returns false" do
+            expect(described_class.send(method, "0")).to eq(false)
+          end
         end
-      end
 
-      context "when provided 0.0" do
+        context "when provided 0.0" do
 
-        it "returns false" do
-          expect(described_class.mongoize("0.0")).to eq(false)
+          it "returns false" do
+            expect(described_class.send(method, "0.0")).to eq(false)
+          end
         end
-      end
 
-      context "when provided no" do
+        context "when provided no" do
 
-        it "returns false" do
-          expect(described_class.mongoize("no")).to eq(false)
+          it "returns false" do
+            expect(described_class.send(method, "no")).to eq(false)
+          end
         end
-      end
 
-      context "when provided n" do
+        context "when provided n" do
 
-        it "returns false" do
-          expect(described_class.mongoize("n")).to eq(false)
+          it "returns false" do
+            expect(described_class.send(method, "n")).to eq(false)
+          end
         end
-      end
 
-      context "when provided off" do
+        context "when provided off" do
 
-        it "returns true" do
-          expect(described_class.mongoize("off")).to eq(false)
+          it "returns true" do
+            expect(described_class.send(method, "off")).to eq(false)
+          end
         end
       end
     end

data/spec/mongoid/extensions/date_class_mongoize_spec.rb

@@ -98,19 +98,23 @@ describe Mongoid::Extensions::Date do
 
       context "when the string is empty" do
 
-        let(:evolved) do
+        let(:mongoized) do
           Date.mongoize("")
         end
 
         it "returns nil" do
-          expect(evolved).to be_nil
+          expect(mongoized).to be_nil
         end
       end
 
       context "when the string is an invalid time" do
 
+        let(:mongoized) do
+          Date.mongoize("time")
+        end
+
         it "returns nil" do
-          expect(Date.mongoize("time")).to eq(nil)
+          expect(mongoized).to be_nil
         end
       end
     end

data/spec/mongoid/extensions/date_spec.rb

@@ -54,12 +54,37 @@ 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
+
+    context "when demongoizing nil" do
+
+      it "returns nil" do
+        expect(Date.demongoize(nil)).to be_nil
+      end
+    end
+
+    context "when demongoizing a bogus value" do
+
+      it "returns nil" do
+        expect(Date.demongoize("bogus")).to be_nil
+      end
+    end
+
+    context "when demongoizing a string" do
+
+      let(:date) { "2022-07-11 14:03:42 -0400" }
+
+      it "returns a date" do
+        expect(Date.demongoize(date)).to eq(date.to_date)
+      end
+    end
   end
 
   describe "#mongoize" do
@@ -76,4 +101,49 @@ describe Mongoid::Extensions::Date do
       expect(date.mongoize).to eq(time)
     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
+
+    let(:datetime) do
+      time.to_datetime
+    end
+
+    context "when the value is a date" do
+
+      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 the value is a time" do
+
+      it "keeps the time" do
+        expect(Date.mongoize(time)).to eq(date)
+        expect(Date.mongoize(time)).to be_a(Time)
+      end
+    end
+
+    context "when the value is a datetime" do
+
+      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 the value is uncastable" do
+
+      it "returns nil" do
+        expect(Date.mongoize("bogus")).to be_nil
+      end
+    end
+  end
 end

data/spec/mongoid/extensions/date_time_spec.rb

@@ -52,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
 
@@ -80,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/float_spec.rb

@@ -35,118 +35,90 @@ describe Mongoid::Extensions::Float do
     end
   end
 
-  describe ".demongoize" do
+  [ :mongoize, :demongoize ].each do |method|
 
-    context "when the value is a float" do
+    describe ".#{method}" do
 
-      it "returns a float" do
-        expect(Float.demongoize(number)).to eq(number)
-      end
-    end
-
-    context "when the value is nil" do
-
-      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
-    end
-
-    context "when the value is not a float string" do
+      context "when the value is a number" do
 
-      it "returns a float" do
-        expect(Float.demongoize('asdf')).to eq(0)
-      end
-    end
-  end
+        context "when the value is an float" do
 
-  describe ".mongoize" do
+          context "when the value is small" do
 
-    context "when the value is a number" do
+            it "it returns the float" do
+              expect(Float.send(method, 3)).to eq(3)
+            end
 
-      context "when the value is an float" do
-
-        context "when the value is small" do
-
-          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)
-          end
-        end
+          context "when the value is large" do
 
-        context "when the value is large" do
-
-          it "returns the float" do
-            expect(Float.mongoize(1024**2).to_s).to eq("1048576.0")
+            it "returns the float" do
+              expect(Float.send(method, 1024**2).to_s).to eq("1048576.0")
+            end
           end
         end
-      end
 
-      context "when the value is a decimal" do
+        context "when the value is a decimal" do
 
-        it "casts to float" do
-          expect(Float.mongoize(2.5)).to eq(2.5)
+          it "casts to float" do
+            expect(Float.send(method, 2.5)).to eq(2.5)
+          end
         end
-      end
 
-      context "when the value is floating point zero" do
+        context "when the value is floating point zero" do
 
-        it "returns the float zero" do
-          expect(Float.mongoize(0.00000)).to eq(0)
+          it "returns the float zero" do
+            expect(Float.send(method, 0.00000)).to eq(0)
+          end
         end
-      end
 
-      context "when the value is a floating point float" do
+        context "when the value is a floating point float" do
 
-        it "returns the float number" do
-          expect(Float.mongoize(4.00000)).to eq(4)
+          it "returns the float number" do
+            expect(Float.send(method, 4.00000)).to eq(4)
+          end
         end
-      end
 
-      context "when the value has leading zeros" do
+        context "when the value has leading zeros" do
 
-        it "returns the stripped float" do
-          expect(Float.mongoize("000011")).to eq(11)
+          it "returns the stripped float" do
+            expect(Float.send(method, "000011")).to eq(11)
+          end
         end
       end
-    end
 
-    context "when the string is not a number" do
+      context "when the string is not a number" do
 
-      context "when the string is non numerical" do
+        context "when the string is non numerical" do
 
-        it "returns 0" do
-          expect(Float.mongoize("foo")).to eq(0.0)
+          it "returns nil" do
+            expect(Float.send(method, "foo")).to be_nil
+          end
         end
-      end
 
-      context "when the string is numerical" do
+        context "when the string is numerical" do
 
-        it "returns the float value for the string" do
-          expect(Float.mongoize("3")).to eq(3)
+          it "returns the float value for the string" do
+            expect(Float.send(method, "3")).to eq(3)
+          end
         end
-      end
 
-      context "when the string is empty" do
+        context "when the string is empty" do
 
-        it "returns nil" do
-          expect(Float.mongoize("")).to be_nil
+          it "returns nil" do
+            expect(Float.send(method, "")).to be_nil
+          end
         end
-      end
 
-      context "when the string is nil" do
+        context "when the string is nil" do
 
-        it "returns nil" do
-          expect(Float.mongoize(nil)).to be_nil
+          it "returns nil" do
+            expect(Float.send(method, nil)).to be_nil
+          end
         end
       end
     end

data/spec/mongoid/extensions/hash_spec.rb

@@ -290,6 +290,26 @@ describe Mongoid::Extensions::Hash do
     it "returns the hash" do
       expect(Hash.demongoize(hash)).to eq(hash)
     end
+
+    context "when object is nil" do
+      let(:demongoized) do
+        Hash.demongoize(nil)
+      end
+
+      it "returns nil" do
+        expect(demongoized).to be_nil
+      end
+    end
+
+    context "when the object is uncastable" do
+      let(:demongoized) do
+        Hash.demongoize(1)
+      end
+
+      it "returns the object" do
+        expect(demongoized).to eq(1)
+      end
+    end
   end
 
   describe ".mongoize" do
@@ -326,6 +346,16 @@ describe Mongoid::Extensions::Hash do
         expect(mongoized).to be_nil
       end
     end
+
+    context "when the object is uncastable" do
+      let(:mongoized) do
+        Hash.mongoize(1)
+      end
+
+      it "returns nil" do
+        expect(mongoized).to be_nil
+      end
+    end
   end
 
   describe "#mongoize" do