mongoid 3.1.7 → 4.0.2

data/spec/mongoid/extensions/boolean_spec.rb

@@ -1,20 +1,20 @@
 require "spec_helper"
 
-describe Mongoid::Extensions::Boolean do
+describe Mongoid::Boolean do
 
   describe ".demongoize" do
 
     context "when provided true" do
 
       it "returns true" do
-        Boolean.demongoize(true).should eq(true)
+        expect(described_class.demongoize(true)).to eq(true)
       end
     end
 
     context "when provided false" do
 
       it "returns false" do
-        Boolean.demongoize(false).should eq(false)
+        expect(described_class.demongoize(false)).to eq(false)
       end
     end
   end
@@ -26,14 +26,14 @@ describe Mongoid::Extensions::Boolean do
       context "when provided true" do
 
         it "returns true" do
-          Boolean.mongoize(true).should eq(true)
+          expect(described_class.mongoize(true)).to eq(true)
         end
       end
 
       context "when provided false" do
 
         it "returns false" do
-          Boolean.mongoize(false).should eq(false)
+          expect(described_class.mongoize(false)).to eq(false)
         end
       end
     end
@@ -43,84 +43,84 @@ describe Mongoid::Extensions::Boolean do
       context "when provided true" do
 
         it "returns true" do
-          Boolean.mongoize("true").should eq(true)
+          expect(described_class.mongoize("true")).to eq(true)
         end
       end
 
       context "when provided t" do
 
         it "returns true" do
-          Boolean.mongoize("t").should eq(true)
+          expect(described_class.mongoize("t")).to eq(true)
         end
       end
 
       context "when provided 1" do
 
         it "returns true" do
-          Boolean.mongoize("1").should eq(true)
+          expect(described_class.mongoize("1")).to eq(true)
         end
       end
 
       context "when provided 1.0" do
 
         it "returns true" do
-          Boolean.mongoize("1.0").should eq(true)
+          expect(described_class.mongoize("1.0")).to eq(true)
         end
       end
 
       context "when provided yes" do
 
         it "returns true" do
-          Boolean.mongoize("yes").should eq(true)
+          expect(described_class.mongoize("yes")).to eq(true)
         end
       end
 
       context "when provided y" do
 
         it "returns true" do
-          Boolean.mongoize("y").should eq(true)
+          expect(described_class.mongoize("y")).to eq(true)
         end
       end
 
       context "when provided false" do
 
         it "returns false" do
-          Boolean.mongoize("false").should eq(false)
+          expect(described_class.mongoize("false")).to eq(false)
         end
       end
 
       context "when provided f" do
 
         it "returns false" do
-          Boolean.mongoize("f").should eq(false)
+          expect(described_class.mongoize("f")).to eq(false)
         end
       end
 
       context "when provided 0" do
 
         it "returns false" do
-          Boolean.mongoize("0").should eq(false)
+          expect(described_class.mongoize("0")).to eq(false)
         end
       end
 
       context "when provided 0.0" do
 
         it "returns false" do
-          Boolean.mongoize("0.0").should eq(false)
+          expect(described_class.mongoize("0.0")).to eq(false)
         end
       end
 
       context "when provided no" do
 
         it "returns false" do
-          Boolean.mongoize("no").should eq(false)
+          expect(described_class.mongoize("no")).to eq(false)
         end
       end
 
       context "when provided n" do
 
         it "returns false" do
-          Boolean.mongoize("n").should eq(false)
+          expect(described_class.mongoize("n")).to eq(false)
         end
       end
     end
@@ -129,7 +129,7 @@ describe Mongoid::Extensions::Boolean do
   describe "#mongoize" do
 
     it "returns self" do
-      true.mongoize.should eq(true)
+      expect(true.mongoize).to eq(true)
     end
   end
 end

data/spec/mongoid/extensions/date_spec.rb

@@ -28,7 +28,7 @@ describe Mongoid::Extensions::Date do
       end
 
       it "returns the date as a local time" do
-        mongoized.should eq(expected)
+        expect(mongoized).to eq(expected)
       end
     end
 
@@ -56,7 +56,7 @@ describe Mongoid::Extensions::Date do
       end
 
       it "returns the date as a local time" do
-        mongoized.should eq(expected)
+        expect(mongoized).to eq(expected)
       end
     end
   end
@@ -72,11 +72,11 @@ describe Mongoid::Extensions::Date do
     end
 
     it "keeps the date" do
-      Date.demongoize(time).should eq(expected)
+      expect(Date.demongoize(time)).to eq(expected)
     end
 
     it "converts to a date" do
-      Date.demongoize(time).should be_a(Date)
+      expect(Date.demongoize(time)).to be_a(Date)
     end
   end
 
@@ -97,7 +97,7 @@ describe Mongoid::Extensions::Date do
       end
 
       it "returns the time" do
-        evolved.should eq(expected)
+        expect(evolved).to eq(expected)
       end
     end
 
@@ -118,7 +118,7 @@ describe Mongoid::Extensions::Date do
         end
 
         it "returns the string as a time" do
-          evolved.should eq(expected)
+          expect(evolved).to eq(expected)
         end
       end
 
@@ -129,7 +129,7 @@ describe Mongoid::Extensions::Date do
         end
 
         it "returns nil" do
-          evolved.should be_nil
+          expect(evolved).to be_nil
         end
       end
 
@@ -140,7 +140,7 @@ describe Mongoid::Extensions::Date do
         end
 
         it "returns epoch" do
-          Date.mongoize("time").should eq(epoch)
+          expect(Date.mongoize("time")).to eq(epoch)
         end
       end
     end
@@ -164,7 +164,7 @@ describe Mongoid::Extensions::Date do
       end
 
       it "returns the float as a time" do
-        evolved.should eq(Time.utc(expected.year, expected.month, expected.day))
+        expect(evolved).to eq(Time.utc(expected.year, expected.month, expected.day))
       end
     end
 
@@ -187,7 +187,7 @@ describe Mongoid::Extensions::Date do
       end
 
       it "returns the integer as a time" do
-        evolved.should eq(Time.utc(expected.year, expected.month, expected.day))
+        expect(evolved).to eq(Time.utc(expected.year, expected.month, expected.day))
       end
     end
 
@@ -206,14 +206,14 @@ describe Mongoid::Extensions::Date do
       end
 
       it "returns the array as a time" do
-        evolved.should eq(time)
+        expect(evolved).to eq(time)
       end
     end
 
     context "when provided nil" do
 
       it "returns nil" do
-        Date.mongoize(nil).should be_nil
+        expect(Date.mongoize(nil)).to be_nil
       end
     end
   end
@@ -229,7 +229,7 @@ describe Mongoid::Extensions::Date do
     end
 
     it "returns the date as a time at midnight" do
-      date.mongoize.should eq(time)
+      expect(date.mongoize).to eq(time)
     end
   end
 end

data/spec/mongoid/extensions/date_time_spec.rb

@@ -15,7 +15,7 @@ describe Mongoid::Extensions::DateTime do
       end
 
       it "does not drop the precision" do
-        mongoized.to_f.to_s.should match(/\.123/)
+        expect(mongoized.to_f.to_s).to match(/\.123/)
       end
     end
 
@@ -43,7 +43,7 @@ describe Mongoid::Extensions::DateTime do
       end
 
       it "returns the date as a local time" do
-        mongoized.should eq(expected)
+        expect(mongoized).to eq(expected)
       end
     end
 
@@ -71,7 +71,7 @@ describe Mongoid::Extensions::DateTime do
       end
 
       it "returns the date as a utc time" do
-        mongoized.should eq(expected)
+        expect(mongoized).to eq(expected)
       end
     end
   end
@@ -87,11 +87,11 @@ describe Mongoid::Extensions::DateTime do
     end
 
     it "converts to a datetime" do
-      date_time.should be_kind_of(DateTime)
+      expect(date_time).to be_kind_of(DateTime)
     end
 
     it "does not change the time" do
-      DateTime.demongoize(time).should eq(time)
+      expect(DateTime.demongoize(time)).to eq(time)
     end
 
     context "when using utc" do
@@ -119,7 +119,7 @@ describe Mongoid::Extensions::DateTime do
         end
 
         it "does not return the time with time zone applied" do
-          user.last_login.should eq(date)
+          expect(user.last_login).to eq(date)
         end
       end
     end
@@ -134,7 +134,7 @@ describe Mongoid::Extensions::DateTime do
       end
 
       it "returns epoch" do
-        DateTime.mongoize("time").should eq(epoch)
+        expect(DateTime.mongoize("time")).to eq(epoch)
       end
     end
   end
@@ -148,7 +148,7 @@ describe Mongoid::Extensions::DateTime do
     context "when the string is an invalid time" do
 
       it "returns the date time as a time" do
-        date_time.mongoize.should be_a(Time)
+        expect(date_time.mongoize).to be_a(Time)
       end
     end
   end

data/spec/mongoid/extensions/false_class_spec.rb

@@ -5,7 +5,7 @@ describe Mongoid::Extensions::FalseClass do
   describe "#__sortable__" do
 
     it "returns 0" do
-      false.__sortable__.should eq(0)
+      expect(false.__sortable__).to eq(0)
     end
   end
 
@@ -14,28 +14,28 @@ describe Mongoid::Extensions::FalseClass do
     context "when provided a Boolean" do
 
       it "returns true" do
-        false.is_a?(Boolean).should be_true
+        expect(false.is_a?(Boolean)).to be true
       end
     end
 
     context "when provided a FalseClass" do
 
       it "returns true" do
-        false.is_a?(FalseClass).should be_true
+        expect(false.is_a?(FalseClass)).to be true
       end
     end
 
     context "when provided a TrueClass" do
 
       it "returns false" do
-        false.is_a?(TrueClass).should be_false
+        expect(false.is_a?(TrueClass)).to be false
       end
     end
 
     context "when provided an invalid class" do
 
       it "returns false" do
-        false.is_a?(String).should be_false
+        expect(false.is_a?(String)).to be false
       end
     end
   end

data/spec/mongoid/extensions/float_spec.rb

@@ -17,7 +17,7 @@ describe Mongoid::Extensions::Float do
     end
 
     it "returns the float as a time" do
-      mongoized.should eq(Time.at(float))
+      expect(mongoized).to eq(Time.at(float))
     end
   end
 
@@ -26,14 +26,28 @@ describe Mongoid::Extensions::Float do
     context "when the the value is a float" do
 
       it "returns a float" do
-        Float.demongoize(number).should eq(number)
+        expect(Float.demongoize(number)).to eq(number)
       end
     end
 
     context "when the value is nil" do
 
       it "returns nil" do
-        Float.demongoize(nil).should be_nil
+        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
+
+      it "returns a float" do
+        expect(Float.demongoize('asdf')).to eq(0)
       end
     end
   end
@@ -47,18 +61,18 @@ describe Mongoid::Extensions::Float do
         context "when the value is small" do
 
           it "it returns the float" do
-            Float.mongoize(3).should eq(3)
+            expect(Float.mongoize(3)).to eq(3)
           end
 
           it "returns the number as type float" do
-            Float.mongoize(3).should be_a(Float)
+            expect(Float.mongoize(3)).to be_a(Float)
           end
         end
 
         context "when the value is large" do
 
           it "returns the float" do
-            Float.mongoize(1024**2).to_s.should eq("1048576.0")
+            expect(Float.mongoize(1024**2).to_s).to eq("1048576.0")
           end
         end
       end
@@ -66,28 +80,28 @@ describe Mongoid::Extensions::Float do
       context "when the value is a decimal" do
 
         it "casts to float" do
-          Float.mongoize(2.5).should eq(2.5)
+          expect(Float.mongoize(2.5)).to eq(2.5)
         end
       end
 
       context "when the value is floating point zero" do
 
         it "returns the float zero" do
-          Float.mongoize(0.00000).should eq(0)
+          expect(Float.mongoize(0.00000)).to eq(0)
         end
       end
 
       context "when the value is a floating point float" do
 
         it "returns the float number" do
-          Float.mongoize(4.00000).should eq(4)
+          expect(Float.mongoize(4.00000)).to eq(4)
         end
       end
 
       context "when the value has leading zeros" do
 
         it "returns the stripped float" do
-          Float.mongoize("000011").should eq(11)
+          expect(Float.mongoize("000011")).to eq(11)
         end
       end
     end
@@ -97,28 +111,28 @@ describe Mongoid::Extensions::Float do
       context "when the string is non numerical" do
 
         it "returns 0" do
-          Float.mongoize("foo").should eq(0.0)
+          expect(Float.mongoize("foo")).to eq(0.0)
         end
       end
 
       context "when the string is numerical" do
 
         it "returns the float value for the string" do
-          Float.mongoize("3").should eq(3)
+          expect(Float.mongoize("3")).to eq(3)
         end
       end
 
       context "when the string is empty" do
 
         it "returns nil" do
-          Float.mongoize("").should be_nil
+          expect(Float.mongoize("")).to be_nil
         end
       end
 
       context "when the string is nil" do
 
         it "returns nil" do
-          Float.mongoize(nil).should be_nil
+          expect(Float.mongoize(nil)).to be_nil
         end
       end
     end
@@ -127,7 +141,7 @@ describe Mongoid::Extensions::Float do
   describe "#mongoize" do
 
     it "returns self" do
-      number.mongoize.should eq(number)
+      expect(number.mongoize).to eq(number)
     end
   end
 end