mongoid 3.1.6 → 4.0.2

data/spec/mongoid/extensions/symbol_spec.rb

@@ -7,14 +7,14 @@ describe Mongoid::Extensions::Symbol do
     context "when the object is not a symbol" do
 
       it "returns the symbol" do
-        Symbol.demongoize("test").should eq(:test)
+        expect(Symbol.demongoize("test")).to eq(:test)
       end
     end
 
     context "when the object is nil" do
 
       it "returns nil" do
-        Symbol.demongoize(nil).should be_nil
+        expect(Symbol.demongoize(nil)).to be_nil
       end
     end
   end
@@ -24,28 +24,28 @@ describe Mongoid::Extensions::Symbol do
     context "when the string is id" do
 
       it "returns true" do
-        :id.should be_mongoid_id
+        expect(:id).to be_mongoid_id
       end
     end
 
     context "when the string is _id" do
 
       it "returns true" do
-        :_id.should be_mongoid_id
+        expect(:_id).to be_mongoid_id
       end
     end
 
     context "when the string contains id" do
 
       it "returns false" do
-        :identity.should_not be_mongoid_id
+        expect(:identity).to_not be_mongoid_id
       end
     end
 
     context "when the string contains _id" do
 
       it "returns false" do
-        :something_id.should_not be_mongoid_id
+        expect(:something_id).to_not be_mongoid_id
       end
     end
   end
@@ -55,14 +55,14 @@ describe Mongoid::Extensions::Symbol do
     context "when the object is not a symbol" do
 
       it "returns the symbol" do
-        Symbol.mongoize("test").should eq(:test)
+        expect(Symbol.mongoize("test")).to eq(:test)
       end
     end
 
     context "when the object is nil" do
 
       it "returns nil" do
-        Symbol.mongoize(nil).should be_nil
+        expect(Symbol.mongoize(nil)).to be_nil
       end
     end
   end
@@ -70,7 +70,7 @@ describe Mongoid::Extensions::Symbol do
   describe "#mongoize" do
 
     it "returns self" do
-      :test.mongoize.should eq(:test)
+      expect(:test.mongoize).to eq(:test)
     end
   end
 end

data/spec/mongoid/extensions/time_spec.rb

@@ -26,7 +26,7 @@ describe Mongoid::Extensions::Time do
         end
 
         it "returns the local time" do
-          Time.demongoize(time).utc_offset.should eq(
+          expect(Time.demongoize(time).utc_offset).to eq(
             Time.local(2010, 11, 19).utc_offset
           )
         end
@@ -39,7 +39,7 @@ describe Mongoid::Extensions::Time do
         end
 
         it "returns the local time" do
-          Time.demongoize(time).should eq(time.getlocal)
+          expect(Time.demongoize(time)).to eq(time.getlocal)
         end
       end
 
@@ -50,7 +50,7 @@ describe Mongoid::Extensions::Time do
         end
 
         it "changes it back to the equivalent local time" do
-          Time.demongoize(time).should eq(time)
+          expect(Time.demongoize(time)).to eq(time)
         end
       end
 
@@ -67,7 +67,7 @@ describe Mongoid::Extensions::Time do
         end
 
         it "returns an ActiveSupport::TimeWithZone" do
-          Time.demongoize(time).class.should eq(ActiveSupport::TimeWithZone)
+          expect(Time.demongoize(time).class).to eq(ActiveSupport::TimeWithZone)
         end
 
         context "when the local time is not observing daylight saving" do
@@ -77,7 +77,7 @@ describe Mongoid::Extensions::Time do
           end
 
           it "returns the local time" do
-            Time.demongoize(new_time).should eq(
+            expect(Time.demongoize(new_time)).to eq(
               Time.zone.local(2010, 11, 19, 13)
             )
           end
@@ -90,7 +90,7 @@ describe Mongoid::Extensions::Time do
           end
 
           it "returns the local time" do
-            Time.demongoize(new_time).should eq(
+            expect(Time.demongoize(new_time)).to eq(
               Time.zone.local(2010, 9, 19, 14)
             )
           end
@@ -103,7 +103,7 @@ describe Mongoid::Extensions::Time do
           end
 
           it "change it back to the equivalent local time" do
-            Time.demongoize(new_time).should eq(
+            expect(Time.demongoize(new_time)).to eq(
               Time.zone.local(2010, 11, 19, 1, 30)
             )
           end
@@ -122,7 +122,7 @@ describe Mongoid::Extensions::Time do
       end
 
       it "returns utc" do
-        Time.demongoize(time.dup.utc).utc_offset.should eq(0)
+        expect(Time.demongoize(time.dup.utc).utc_offset).to eq(0)
       end
 
       context "when using the ActiveSupport time zone" do
@@ -142,13 +142,13 @@ describe Mongoid::Extensions::Time do
         end
 
         it "returns utc" do
-          Time.demongoize(time).should eq(
+          expect(Time.demongoize(time)).to eq(
             ActiveSupport::TimeZone['UTC'].local(2010, 11, 19, 0, 30)
           )
         end
 
         it "returns an ActiveSupport::TimeWithZone" do
-          Time.demongoize(time).class.should eq(
+          expect(Time.demongoize(time).class).to eq(
             ActiveSupport::TimeWithZone
           )
         end
@@ -158,7 +158,7 @@ describe Mongoid::Extensions::Time do
     context "when time is nil" do
 
       it "returns nil" do
-        Time.demongoize(nil).should be_nil
+        expect(Time.demongoize(nil)).to be_nil
       end
     end
   end
@@ -172,14 +172,14 @@ describe Mongoid::Extensions::Time do
     context "when given nil" do
 
       it "returns nil" do
-        Time.mongoize(nil).should be_nil
+        expect(Time.mongoize(nil)).to be_nil
       end
     end
 
     context "when string is empty" do
 
       it "returns nil" do
-        Time.mongoize("").should be_nil
+        expect(Time.mongoize("")).to be_nil
       end
     end
 
@@ -188,15 +188,15 @@ describe Mongoid::Extensions::Time do
       context "when the string is a valid time" do
 
         it "converts to a utc time" do
-          Time.mongoize(time.to_s).utc_offset.should eq(0)
+          expect(Time.mongoize(time.to_s).utc_offset).to eq(0)
         end
 
         it "serializes with time parsing" do
-          Time.mongoize(time.to_s).should eq(Time.parse(time.to_s).utc)
+          expect(Time.mongoize(time.to_s)).to eq(Time.parse(time.to_s).utc)
         end
 
         it "returns a local date from the string" do
-          Time.mongoize(time.to_s).should eq(
+          expect(Time.mongoize(time.to_s)).to eq(
             Time.local(time.year, time.month, time.day, time.hour, time.min, time.sec)
           )
         end
@@ -209,7 +209,7 @@ describe Mongoid::Extensions::Time do
         end
 
         it "converts the time to epoch" do
-          Time.mongoize("time").should eq(epoch)
+          expect(Time.mongoize("time")).to eq(epoch)
         end
       end
 
@@ -229,7 +229,7 @@ describe Mongoid::Extensions::Time do
         context "when the local time is not observing daylight saving" do
 
           it "returns the local time" do
-            Time.mongoize('2010-11-19 5:00:00').should eq(
+            expect(Time.mongoize('2010-11-19 5:00:00')).to eq(
               Time.utc(2010, 11, 19, 4)
             )
           end
@@ -238,7 +238,7 @@ describe Mongoid::Extensions::Time do
         context "when the local time is observing daylight saving" do
 
           it "returns the local time" do
-            Time.mongoize('2010-9-19 5:00:00').should eq(
+            expect(Time.mongoize('2010-9-19 5:00:00')).to eq(
               Time.utc(2010, 9, 19, 3)
             )
           end
@@ -261,27 +261,27 @@ describe Mongoid::Extensions::Time do
       end
 
       it "doesn't strip milli- or microseconds" do
-        Time.mongoize(time).to_f.round(3).should eq(time.to_f.round(3))
+        expect(Time.mongoize(time).to_f).to eq(time.to_time.to_f)
       end
 
       it "doesn't round up the hour at end of month" do
-        eom_time_mongoized.hour.should eq(eom_time.utc.hour)
+        expect(eom_time_mongoized.hour).to eq(eom_time.utc.hour)
       end
 
       it "doesn't round up the minute" do
-        eom_time_mongoized.min.should eq(eom_time.utc.min)
+        expect(eom_time_mongoized.min).to eq(eom_time.utc.min)
       end
 
       it "doesn't round up the seconds" do
-        eom_time_mongoized.sec.should eq(eom_time.utc.sec)
+        expect(eom_time_mongoized.sec).to eq(eom_time.utc.sec)
       end
 
       it "does not alter seconds" do
-        (eom_time_mongoized.usec).should eq(999999)
+        expect((eom_time_mongoized.usec)).to eq(999999)
       end
 
       it "does not alter seconds with fractions" do
-        DateTime.mongoize(11.11).to_f.should eq(11.11)
+        expect(DateTime.mongoize(11.11).to_f).to eq(11.11)
       end
 
       context "when using the ActiveSupport time zone" do
@@ -302,25 +302,25 @@ describe Mongoid::Extensions::Time do
         end
 
         it "assumes the given time is local" do
-          Time.mongoize(datetime).should eq(
+          expect(Time.mongoize(datetime)).to eq(
             Time.utc(2010, 11, 19)
           )
         end
 
         it "doesn't round up the hour" do
-          eom_time_mongoized.hour.should eq(eom_time.utc.hour)
+          expect(eom_time_mongoized.hour).to eq(eom_time.utc.hour)
         end
 
         it "doesn't round up the minutes" do
-          eom_time_mongoized.min.should eq(eom_time.utc.min)
+          expect(eom_time_mongoized.min).to eq(eom_time.utc.min)
         end
 
         it "doesn't round up the seconds" do
-          eom_time_mongoized.sec.should eq(eom_time.utc.sec)
+          expect(eom_time_mongoized.sec).to eq(eom_time.utc.sec)
         end
 
         it "does not alter the seconds" do
-          (eom_time_mongoized.usec).should eq(999999)
+          expect((eom_time_mongoized.usec)).to eq(999999)
         end
       end
     end
@@ -328,23 +328,23 @@ describe Mongoid::Extensions::Time do
     context "when given a Time" do
 
       it "converts to a utc time" do
-        Time.mongoize(time).utc_offset.should eq(0)
+        expect(Time.mongoize(time).utc_offset).to eq(0)
       end
 
       it "returns utc times unchanged" do
-        Time.mongoize(time.utc).should eq(time.utc)
+        expect(Time.mongoize(time.utc)).to eq(time.utc)
       end
 
       it "returns the time as utc" do
-        Time.mongoize(time).should eq(time.utc)
+        expect(Time.mongoize(time)).to eq(time.utc)
       end
 
       it "doesn't strip milli- or microseconds" do
-        Time.mongoize(time).to_f.should eq(time.to_f)
+        expect(Time.mongoize(time).to_f).to eq(time.to_f)
       end
 
       it "does not alter seconds with fractions" do
-        Time.mongoize(102.63).to_f.should eq(102.63)
+        expect(Time.mongoize(102.63).to_f).to eq(102.63)
       end
     end
 
@@ -355,7 +355,7 @@ describe Mongoid::Extensions::Time do
       end
 
       it "converts it to utc" do
-        Time.mongoize(time.in_time_zone("Alaska")).should eq(
+        expect(Time.mongoize(time.in_time_zone("Alaska"))).to eq(
           Time.at(time.to_i).utc
         )
       end
@@ -368,11 +368,11 @@ describe Mongoid::Extensions::Time do
       end
 
       it "converts to a utc time" do
-        Time.mongoize(date).should eq(Time.local(date.year, date.month, date.day))
+        expect(Time.mongoize(date)).to eq(Time.local(date.year, date.month, date.day))
       end
 
       it "has a zero utc offset" do
-        Time.mongoize(date).utc_offset.should eq(0)
+        expect(Time.mongoize(date).utc_offset).to eq(0)
       end
 
       context "when using the ActiveSupport time zone" do
@@ -393,7 +393,7 @@ describe Mongoid::Extensions::Time do
         end
 
         it "assumes the given time is local" do
-          Time.mongoize(date).should eq(Time.utc(2010, 11, 18, 23))
+          expect(Time.mongoize(date)).to eq(Time.utc(2010, 11, 18, 23))
         end
       end
     end
@@ -405,7 +405,7 @@ describe Mongoid::Extensions::Time do
       end
 
       it "returns a time" do
-        Time.mongoize(array).should eq(Time.local(*array))
+        expect(Time.mongoize(array)).to eq(Time.local(*array))
       end
 
       context "when using the ActiveSupport time zone" do
@@ -422,7 +422,7 @@ describe Mongoid::Extensions::Time do
         end
 
         it "assumes the given time is local" do
-          Time.mongoize(array).should eq(
+          expect(Time.mongoize(array)).to eq(
             Time.utc(2010, 11, 18, 23, 24, 49)
           )
         end
@@ -445,23 +445,23 @@ describe Mongoid::Extensions::Time do
     end
 
     it "converts to a utc time" do
-      time.mongoize.utc_offset.should eq(0)
+      expect(time.mongoize.utc_offset).to eq(0)
     end
 
     it "returns the time as utc" do
-      time.mongoize.should eq(time.utc)
+      expect(time.mongoize).to eq(time.utc)
     end
 
     it "doesn't strip milli- or microseconds" do
-      time.mongoize.to_f.should eq(time.to_f)
+      expect(time.mongoize.to_f).to eq(time.to_f)
     end
 
     it "doesn't round up at end of month" do
-      eom_time_mongoized.hour.should eq(eom_time.utc.hour)
-      eom_time_mongoized.min.should eq(eom_time.utc.min)
-      eom_time_mongoized.sec.should eq(eom_time.utc.sec)
-      eom_time_mongoized.usec.should eq(eom_time.utc.usec)
-      eom_time_mongoized.subsec.to_f.round(3).should eq(eom_time.utc.subsec.to_f.round(3))
+      expect(eom_time_mongoized.hour).to eq(eom_time.utc.hour)
+      expect(eom_time_mongoized.min).to eq(eom_time.utc.min)
+      expect(eom_time_mongoized.sec).to eq(eom_time.utc.sec)
+      expect(eom_time_mongoized.usec).to eq(eom_time.utc.usec)
+      expect(eom_time_mongoized.subsec.to_f.round(3)).to eq(eom_time.utc.subsec.to_f.round(3))
     end
   end
 end

data/spec/mongoid/extensions/time_with_zone_spec.rb

@@ -26,7 +26,7 @@ describe Mongoid::Extensions::TimeWithZone do
         end
 
         it "returns the local time" do
-          ActiveSupport::TimeWithZone.demongoize(time).utc_offset.should eq(
+          expect(ActiveSupport::TimeWithZone.demongoize(time).utc_offset).to eq(
             Time.local(2010, 11, 19).utc_offset
           )
         end
@@ -39,7 +39,7 @@ describe Mongoid::Extensions::TimeWithZone do
         end
 
         it "returns the local time" do
-          ActiveSupport::TimeWithZone.demongoize(time).should eq(time.getlocal)
+          expect(ActiveSupport::TimeWithZone.demongoize(time)).to eq(time.getlocal)
         end
       end
 
@@ -50,7 +50,7 @@ describe Mongoid::Extensions::TimeWithZone do
         end
 
         it "changes it back to the equivalent local time" do
-          ActiveSupport::TimeWithZone.demongoize(time).should eq(time)
+          expect(ActiveSupport::TimeWithZone.demongoize(time)).to eq(time)
         end
       end
 
@@ -67,7 +67,7 @@ describe Mongoid::Extensions::TimeWithZone do
         end
 
         it "returns an ActiveSupport::TimeWithZone" do
-          ActiveSupport::TimeWithZone.demongoize(time).class.should eq(ActiveSupport::TimeWithZone)
+          expect(ActiveSupport::TimeWithZone.demongoize(time).class).to eq(ActiveSupport::TimeWithZone)
         end
 
         context "when the local time is not observing daylight saving" do
@@ -77,7 +77,7 @@ describe Mongoid::Extensions::TimeWithZone do
           end
 
           it "returns the local time" do
-            ActiveSupport::TimeWithZone.demongoize(new_time).should eq(
+            expect(ActiveSupport::TimeWithZone.demongoize(new_time)).to eq(
               Time.zone.local(2010, 11, 19, 13)
             )
           end
@@ -90,7 +90,7 @@ describe Mongoid::Extensions::TimeWithZone do
           end
 
           it "returns the local time" do
-            ActiveSupport::TimeWithZone.demongoize(new_time).should eq(
+            expect(ActiveSupport::TimeWithZone.demongoize(new_time)).to eq(
               Time.zone.local(2010, 9, 19, 14)
             )
           end
@@ -103,7 +103,7 @@ describe Mongoid::Extensions::TimeWithZone do
           end
 
           it "change it back to the equivalent local time" do
-            ActiveSupport::TimeWithZone.demongoize(new_time).should eq(
+            expect(ActiveSupport::TimeWithZone.demongoize(new_time)).to eq(
               Time.zone.local(2010, 11, 19, 1, 30)
             )
           end
@@ -122,7 +122,7 @@ describe Mongoid::Extensions::TimeWithZone do
       end
 
       it "returns utc" do
-        ActiveSupport::TimeWithZone.demongoize(time.dup.utc).utc_offset.should eq(0)
+        expect(ActiveSupport::TimeWithZone.demongoize(time.dup.utc).utc_offset).to eq(0)
       end
 
       context "when using the ActiveSupport time zone" do
@@ -142,13 +142,13 @@ describe Mongoid::Extensions::TimeWithZone do
         end
 
         it "returns utc" do
-          ActiveSupport::TimeWithZone.demongoize(time).should eq(
+          expect(ActiveSupport::TimeWithZone.demongoize(time)).to eq(
             ActiveSupport::TimeZone['UTC'].local(2010, 11, 19, 0, 30)
           )
         end
 
         it "returns an ActiveSupport::TimeWithZone" do
-          ActiveSupport::TimeWithZone.demongoize(time).class.should eq(
+          expect(ActiveSupport::TimeWithZone.demongoize(time).class).to eq(
             ActiveSupport::TimeWithZone
           )
         end
@@ -158,7 +158,7 @@ describe Mongoid::Extensions::TimeWithZone do
     context "when time is nil" do
 
       it "returns nil" do
-        ActiveSupport::TimeWithZone.demongoize(nil).should be_nil
+        expect(ActiveSupport::TimeWithZone.demongoize(nil)).to be_nil
       end
     end
   end
@@ -172,14 +172,14 @@ describe Mongoid::Extensions::TimeWithZone do
     context "when given nil" do
 
       it "returns nil" do
-        ActiveSupport::TimeWithZone.mongoize(nil).should be_nil
+        expect(ActiveSupport::TimeWithZone.mongoize(nil)).to be_nil
       end
     end
 
     context "when string is empty" do
 
       it "returns nil" do
-        ActiveSupport::TimeWithZone.mongoize("").should be_nil
+        expect(ActiveSupport::TimeWithZone.mongoize("")).to be_nil
       end
     end
 
@@ -188,15 +188,15 @@ describe Mongoid::Extensions::TimeWithZone do
       context "when the string is a valid time" do
 
         it "converts to a utc time" do
-          ActiveSupport::TimeWithZone.mongoize(time.to_s).utc_offset.should eq(0)
+          expect(ActiveSupport::TimeWithZone.mongoize(time.to_s).utc_offset).to eq(0)
         end
 
         it "serializes with time parsing" do
-          ActiveSupport::TimeWithZone.mongoize(time.to_s).should eq(Time.parse(time.to_s).utc)
+          expect(ActiveSupport::TimeWithZone.mongoize(time.to_s)).to eq(Time.parse(time.to_s).utc)
         end
 
         it "returns a local date from the string" do
-          ActiveSupport::TimeWithZone.mongoize(time.to_s).should eq(
+          expect(ActiveSupport::TimeWithZone.mongoize(time.to_s)).to eq(
             Time.local(time.year, time.month, time.day, time.hour, time.min, time.sec)
           )
         end
@@ -209,7 +209,7 @@ describe Mongoid::Extensions::TimeWithZone do
         end
 
         it "returns epoch" do
-          ActiveSupport::TimeWithZone.mongoize("time").should eq(epoch)
+          expect(ActiveSupport::TimeWithZone.mongoize("time")).to eq(epoch)
         end
       end
 
@@ -229,7 +229,7 @@ describe Mongoid::Extensions::TimeWithZone do
         context "when the local time is not observing daylight saving" do
 
           it "returns the local time" do
-            ActiveSupport::TimeWithZone.mongoize('2010-11-19 5:00:00').should eq(
+            expect(ActiveSupport::TimeWithZone.mongoize('2010-11-19 5:00:00')).to eq(
               Time.utc(2010, 11, 19, 4)
             )
           end
@@ -238,7 +238,7 @@ describe Mongoid::Extensions::TimeWithZone do
         context "when the local time is observing daylight saving" do
 
           it "returns the local time" do
-            ActiveSupport::TimeWithZone.mongoize('2010-9-19 5:00:00').should eq(
+            expect(ActiveSupport::TimeWithZone.mongoize('2010-9-19 5:00:00')).to eq(
               Time.utc(2010, 9, 19, 3)
             )
           end
@@ -253,7 +253,7 @@ describe Mongoid::Extensions::TimeWithZone do
       end
 
       it "doesn't strip milli- or microseconds" do
-        ActiveSupport::TimeWithZone.mongoize(time).to_f.round(4).should eq(
+        expect(ActiveSupport::TimeWithZone.mongoize(time).to_f.round(4)).to eq(
           time.to_f.round(4)
         )
       end
@@ -276,7 +276,7 @@ describe Mongoid::Extensions::TimeWithZone do
         end
 
         it "assumes the given time is local" do
-          ActiveSupport::TimeWithZone.mongoize(datetime).should eq(
+          expect(ActiveSupport::TimeWithZone.mongoize(datetime)).to eq(
             Time.utc(2010, 11, 19)
           )
         end
@@ -286,19 +286,19 @@ describe Mongoid::Extensions::TimeWithZone do
     context "when given a Time" do
 
       it "converts to a utc time" do
-        ActiveSupport::TimeWithZone.mongoize(time).utc_offset.should eq(0)
+        expect(ActiveSupport::TimeWithZone.mongoize(time).utc_offset).to eq(0)
       end
 
       it "returns utc times unchanged" do
-        ActiveSupport::TimeWithZone.mongoize(time.utc).should eq(time.utc)
+        expect(ActiveSupport::TimeWithZone.mongoize(time.utc)).to eq(time.utc)
       end
 
       it "returns the time as utc" do
-        ActiveSupport::TimeWithZone.mongoize(time).should eq(time.utc)
+        expect(ActiveSupport::TimeWithZone.mongoize(time)).to eq(time.utc)
       end
 
       it "doesn't strip milli- or microseconds" do
-        ActiveSupport::TimeWithZone.mongoize(time).to_f.should eq(time.to_f)
+        expect(ActiveSupport::TimeWithZone.mongoize(time).to_f).to eq(time.to_f)
       end
     end
 
@@ -309,7 +309,7 @@ describe Mongoid::Extensions::TimeWithZone do
       end
 
       it "converts it to utc" do
-        ActiveSupport::TimeWithZone.mongoize(time.in_time_zone("Alaska")).should eq(
+        expect(ActiveSupport::TimeWithZone.mongoize(time.in_time_zone("Alaska"))).to eq(
           Time.at(time.to_i).utc
         )
       end
@@ -322,11 +322,11 @@ describe Mongoid::Extensions::TimeWithZone do
       end
 
       it "converts to a utc time" do
-        ActiveSupport::TimeWithZone.mongoize(date).should eq(Time.local(date.year, date.month, date.day))
+        expect(ActiveSupport::TimeWithZone.mongoize(date)).to eq(Time.local(date.year, date.month, date.day))
       end
 
       it "has a zero utc offset" do
-        ActiveSupport::TimeWithZone.mongoize(date).utc_offset.should eq(0)
+        expect(ActiveSupport::TimeWithZone.mongoize(date).utc_offset).to eq(0)
       end
 
       context "when using the ActiveSupport time zone" do
@@ -347,7 +347,7 @@ describe Mongoid::Extensions::TimeWithZone do
         end
 
         it "assumes the given time is local" do
-          ActiveSupport::TimeWithZone.mongoize(date).should eq(Time.utc(2010, 11, 18, 23))
+          expect(ActiveSupport::TimeWithZone.mongoize(date)).to eq(Time.utc(2010, 11, 18, 23))
         end
       end
     end
@@ -359,7 +359,7 @@ describe Mongoid::Extensions::TimeWithZone do
       end
 
       it "returns a time" do
-        ActiveSupport::TimeWithZone.mongoize(array).should eq(Time.local(*array))
+        expect(ActiveSupport::TimeWithZone.mongoize(array)).to eq(Time.local(*array))
       end
 
       context "when using the ActiveSupport time zone" do
@@ -376,7 +376,7 @@ describe Mongoid::Extensions::TimeWithZone do
         end
 
         it "assumes the given time is local" do
-          ActiveSupport::TimeWithZone.mongoize(array).should eq(
+          expect(ActiveSupport::TimeWithZone.mongoize(array)).to eq(
             Time.utc(2010, 11, 18, 23, 24, 49)
           )
         end
@@ -391,15 +391,15 @@ describe Mongoid::Extensions::TimeWithZone do
     end
 
     it "converts to a utc time" do
-      time.mongoize.utc_offset.should eq(0)
+      expect(time.mongoize.utc_offset).to eq(0)
     end
 
     it "returns the time as utc" do
-      time.mongoize.should eq(time.utc)
+      expect(time.mongoize).to eq(time.utc)
     end
 
     it "doesn't strip milli- or microseconds" do
-      time.mongoize.to_f.should eq(time.to_f)
+      expect(time.mongoize.to_f).to eq(time.to_f)
     end
   end
 end