mongoid 3.1.6 → 4.0.2

data/spec/mongoid/extensions/big_decimal_spec.rb

@@ -11,14 +11,14 @@ describe Mongoid::Extensions::BigDecimal do
     context "when the the value is a string" do
 
       it "returns a big decimal" do
-        BigDecimal.demongoize(number.to_s).should eq(number)
+        expect(BigDecimal.demongoize(number.to_s)).to eq(number)
       end
     end
 
     context "when the value is nil" do
 
       it "returns nil" do
-        BigDecimal.demongoize(nil).should be_nil
+        expect(BigDecimal.demongoize(nil)).to be_nil
       end
     end
 
@@ -29,7 +29,7 @@ describe Mongoid::Extensions::BigDecimal do
       end
 
       it "returns a float" do
-        BigDecimal.demongoize(float).should eq(float)
+        expect(BigDecimal.demongoize(float)).to eq(float)
       end
     end
 
@@ -40,7 +40,7 @@ describe Mongoid::Extensions::BigDecimal do
       end
 
       it "returns an integer" do
-        BigDecimal.demongoize(integer).should eq(integer)
+        expect(BigDecimal.demongoize(integer)).to eq(integer)
       end
     end
 
@@ -55,11 +55,11 @@ describe Mongoid::Extensions::BigDecimal do
       end
 
       it "returns a big decimal" do
-        demongoized.should be_a(BigDecimal)
+        expect(demongoized).to be_a(BigDecimal)
       end
 
       it "is a NaN big decimal" do
-        demongoized.should be_nan
+        expect(demongoized).to be_nan
       end
     end
   end
@@ -69,28 +69,28 @@ describe Mongoid::Extensions::BigDecimal do
     context "when the value is a big decimal" do
 
       it "returns a string" do
-        BigDecimal.mongoize(number).should eq(number.to_s)
+        expect(BigDecimal.mongoize(number)).to eq(number.to_s)
       end
     end
 
     context "when the value is nil" do
 
       it "returns nil" do
-        BigDecimal.mongoize(nil).should be_nil
+        expect(BigDecimal.mongoize(nil)).to be_nil
       end
     end
 
     context "when the value is an integer" do
 
       it "returns a string" do
-        BigDecimal.mongoize(123456).should eq("123456")
+        expect(BigDecimal.mongoize(123456)).to eq("123456")
       end
     end
 
     context "when the value is a float" do
 
       it "returns a string" do
-        BigDecimal.mongoize(123456.789).should eq("123456.789")
+        expect(BigDecimal.mongoize(123456.789)).to eq("123456.789")
       end
     end
   end
@@ -98,7 +98,7 @@ describe Mongoid::Extensions::BigDecimal do
   describe "#mongoize" do
 
     it "returns a string" do
-      number.mongoize.should eq(number.to_s)
+      expect(number.mongoize).to eq(number.to_s)
     end
   end
 end

data/spec/mongoid/extensions/binary_spec.rb

@@ -1,60 +1,60 @@
 require "spec_helper"
 
-describe Moped::BSON::Binary do
+describe BSON::Binary do
 
   describe "#mongoize" do
 
     let(:binary) do
-      Moped::BSON::Binary.new(:md5, "testing")
+      BSON::Binary.new("testing", :md5)
     end
 
     it "returns the binary" do
-      binary.mongoize.should eq(binary)
+      expect(binary.mongoize).to eq(binary)
     end
   end
 
   describe ".demongoize" do
 
     let(:binary) do
-      Moped::BSON::Binary.new(:md5, "testing")
+      BSON::Binary.new("testing", :md5)
     end
 
     let(:demongoized) do
-      Moped::BSON::Binary.demongoize(binary)
+      BSON::Binary.demongoize(binary)
     end
 
     it "returns the binary" do
-      demongoized.should eq(binary)
+      expect(demongoized).to eq(binary)
     end
   end
 
   describe ".evolve" do
 
     let(:binary) do
-      Moped::BSON::Binary.new(:md5, "testing")
+      BSON::Binary.new("testing", :md5)
     end
 
     let(:evolved) do
-      Moped::BSON::Binary.evolve(binary)
+      BSON::Binary.evolve(binary)
     end
 
     it "returns the binary" do
-      evolved.should eq(binary)
+      expect(evolved).to eq(binary)
     end
   end
 
   describe ".mongoize" do
 
     let(:binary) do
-      Moped::BSON::Binary.new(:md5, "testing")
+      BSON::Binary.new("testing", :md5)
     end
 
     let(:mongoized) do
-      Moped::BSON::Binary.mongoize(binary)
+      BSON::Binary.mongoize(binary)
     end
 
     it "returns the binary" do
-      mongoized.should eq(binary)
+      expect(mongoized).to eq(binary)
     end
   end
 end

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