mongoid 3.1.7 → 4.0.0.alpha1

data/spec/mongoid/extensions/module_spec.rb

@@ -19,7 +19,7 @@ describe Mongoid::Extensions::Module do
       end
 
       it "redefines the existing method" do
-        Smoochy.new.sing.should eq("singing again")
+        expect(Smoochy.new.sing).to eq("singing again")
       end
     end
 
@@ -35,7 +35,7 @@ describe Mongoid::Extensions::Module do
       end
 
       it "redefines the existing method" do
-        Rhino.new.sing.should eq("singing")
+        expect(Rhino.new.sing).to eq("singing")
       end
     end
   end

data/spec/mongoid/extensions/nil_class_spec.rb

@@ -5,7 +5,7 @@ describe Mongoid::Extensions::NilClass do
   describe "#collectionize" do
 
     it "returns ''" do
-      nil.collectionize.should be_empty
+      expect(nil.collectionize).to be_empty
     end
   end
 end

data/spec/mongoid/extensions/object_id_spec.rb

@@ -3,7 +3,7 @@ require "spec_helper"
 describe Mongoid::Extensions::ObjectId do
 
   let(:object_id) do
-    Moped::BSON::ObjectId.new
+    BSON::ObjectId.new
   end
 
   let(:composite_key) do
@@ -13,11 +13,11 @@ describe Mongoid::Extensions::ObjectId do
   describe "#__evolve_object_id__" do
 
     it "returns self" do
-      object_id.__evolve_object_id__.should eq(object_id)
+      expect(object_id.__evolve_object_id__).to eq(object_id)
     end
 
     it "returns the same instance" do
-      object_id.__evolve_object_id__.should equal(object_id)
+      expect(object_id.__evolve_object_id__).to equal(object_id)
     end
   end
 
@@ -28,26 +28,26 @@ describe Mongoid::Extensions::ObjectId do
       context "when provided a single object id" do
 
         let(:evolved) do
-          Moped::BSON::ObjectId.evolve(object_id)
+          BSON::ObjectId.evolve(object_id)
         end
 
         it "returns the object id" do
-          evolved.should eq(object_id)
+          expect(evolved).to eq(object_id)
         end
       end
 
       context "when provided an array of object ids" do
 
         let(:other_id) do
-          Moped::BSON::ObjectId.new
+          BSON::ObjectId.new
         end
 
         let(:evolved) do
-          Moped::BSON::ObjectId.evolve([ object_id, other_id ])
+          BSON::ObjectId.evolve([ object_id, other_id ])
         end
 
         it "returns the array of object ids" do
-          evolved.should eq([ object_id, other_id ])
+          expect(evolved).to eq([ object_id, other_id ])
         end
       end
 
@@ -56,18 +56,18 @@ describe Mongoid::Extensions::ObjectId do
         context "when the string is a valid object id" do
 
           let(:evolved) do
-            Moped::BSON::ObjectId.evolve(object_id.to_s)
+            BSON::ObjectId.evolve(object_id.to_s)
           end
 
           it "evolves to an object id" do
-            evolved.should eq(object_id)
+            expect(evolved).to eq(object_id)
           end
         end
 
         context "when the string is not a valid object id" do
 
           it "returns the key" do
-            Moped::BSON::ObjectId.evolve(composite_key).should eq(
+            expect(BSON::ObjectId.evolve(composite_key)).to eq(
               composite_key
             )
           end
@@ -76,11 +76,11 @@ describe Mongoid::Extensions::ObjectId do
         context "when the string is empty" do
 
           let(:evolved) do
-            Moped::BSON::ObjectId.evolve("")
+            BSON::ObjectId.evolve("")
           end
 
           it "evolves to an empty string" do
-            evolved.should be_empty
+            expect(evolved).to be_empty
           end
         end
       end
@@ -90,22 +90,22 @@ describe Mongoid::Extensions::ObjectId do
         context "when array key of nils" do
 
           let(:evolved) do
-            Moped::BSON::ObjectId.evolve([ nil, nil ])
+            BSON::ObjectId.evolve([ nil, nil ])
           end
 
           it "returns the array with nils" do
-            evolved.should eq([ nil, nil ])
+            expect(evolved).to eq([ nil, nil ])
           end
         end
 
         context "when the array key is empty strings" do
 
           let(:evolved) do
-            Moped::BSON::ObjectId.evolve([ "", "" ])
+            BSON::ObjectId.evolve([ "", "" ])
           end
 
           it "returns the array with empty strings" do
-            evolved.should eq([ "", "" ])
+            expect(evolved).to eq([ "", "" ])
           end
         end
 
@@ -114,15 +114,15 @@ describe Mongoid::Extensions::ObjectId do
           context "when the strings are valid object ids" do
 
             let(:other_id) do
-              Moped::BSON::ObjectId.new
+              BSON::ObjectId.new
             end
 
             let(:evolved) do
-              Moped::BSON::ObjectId.evolve([ object_id.to_s, other_id.to_s ])
+              BSON::ObjectId.evolve([ object_id.to_s, other_id.to_s ])
             end
 
             it "evolves to an array of object ids" do
-              evolved.should eq([ object_id, other_id ])
+              expect(evolved).to eq([ object_id, other_id ])
             end
           end
 
@@ -133,11 +133,11 @@ describe Mongoid::Extensions::ObjectId do
             end
 
             let(:evolved) do
-              Moped::BSON::ObjectId.evolve([ composite_key, other_key ])
+              BSON::ObjectId.evolve([ composite_key, other_key ])
             end
 
             it "returns the key" do
-              Moped::BSON::ObjectId.evolve(composite_key).should eq(
+              expect(BSON::ObjectId.evolve(composite_key)).to eq(
                 composite_key
               )
             end
@@ -156,18 +156,18 @@ describe Mongoid::Extensions::ObjectId do
             end
 
             let(:evolved) do
-              Moped::BSON::ObjectId.evolve(hash)
+              BSON::ObjectId.evolve(hash)
             end
 
             it "returns the hash" do
-              evolved.should eq(hash)
+              expect(evolved).to eq(hash)
             end
           end
 
           context "when the value is an array of object ids" do
 
             let(:other_id) do
-              Moped::BSON::ObjectId.new
+              BSON::ObjectId.new
             end
 
             let(:hash) do
@@ -175,11 +175,11 @@ describe Mongoid::Extensions::ObjectId do
             end
 
             let(:evolved) do
-              Moped::BSON::ObjectId.evolve(hash)
+              BSON::ObjectId.evolve(hash)
             end
 
             it "returns the hash" do
-              evolved.should eq(hash)
+              expect(evolved).to eq(hash)
             end
           end
 
@@ -190,18 +190,18 @@ describe Mongoid::Extensions::ObjectId do
             end
 
             let(:evolved) do
-              Moped::BSON::ObjectId.evolve(hash)
+              BSON::ObjectId.evolve(hash)
             end
 
             it "returns the hash with evolved value" do
-              evolved.should eq({ _id: object_id })
+              expect(evolved).to eq({ _id: object_id })
             end
           end
 
           context "when the value is an array of strings" do
 
             let(:other_id) do
-              Moped::BSON::ObjectId.new
+              BSON::ObjectId.new
             end
 
             let(:hash) do
@@ -209,11 +209,11 @@ describe Mongoid::Extensions::ObjectId do
             end
 
             let(:evolved) do
-              Moped::BSON::ObjectId.evolve(hash)
+              BSON::ObjectId.evolve(hash)
             end
 
             it "returns the hash with evolved values" do
-              evolved.should eq({ _id: [ object_id, other_id ] })
+              expect(evolved).to eq({ _id: [ object_id, other_id ] })
             end
           end
         end
@@ -227,18 +227,18 @@ describe Mongoid::Extensions::ObjectId do
             end
 
             let(:evolved) do
-              Moped::BSON::ObjectId.evolve(hash)
+              BSON::ObjectId.evolve(hash)
             end
 
             it "returns the hash" do
-              evolved.should eq(hash)
+              expect(evolved).to eq(hash)
             end
           end
 
           context "when the value is an array of object ids" do
 
             let(:other_id) do
-              Moped::BSON::ObjectId.new
+              BSON::ObjectId.new
             end
 
             let(:hash) do
@@ -246,11 +246,11 @@ describe Mongoid::Extensions::ObjectId do
             end
 
             let(:evolved) do
-              Moped::BSON::ObjectId.evolve(hash)
+              BSON::ObjectId.evolve(hash)
             end
 
             it "returns the hash" do
-              evolved.should eq(hash)
+              expect(evolved).to eq(hash)
             end
           end
 
@@ -261,18 +261,18 @@ describe Mongoid::Extensions::ObjectId do
             end
 
             let(:evolved) do
-              Moped::BSON::ObjectId.evolve(hash)
+              BSON::ObjectId.evolve(hash)
             end
 
             it "returns the hash with evolved value" do
-              evolved.should eq({ id: object_id })
+              expect(evolved).to eq({ id: object_id })
             end
           end
 
           context "when the value is an array of strings" do
 
             let(:other_id) do
-              Moped::BSON::ObjectId.new
+              BSON::ObjectId.new
             end
 
             let(:hash) do
@@ -280,11 +280,11 @@ describe Mongoid::Extensions::ObjectId do
             end
 
             let(:evolved) do
-              Moped::BSON::ObjectId.evolve(hash)
+              BSON::ObjectId.evolve(hash)
             end
 
             it "returns the hash with evolved values" do
-              evolved.should eq({ id: [ object_id, other_id ] })
+              expect(evolved).to eq({ id: [ object_id, other_id ] })
             end
           end
         end
@@ -298,11 +298,11 @@ describe Mongoid::Extensions::ObjectId do
             end
 
             let(:evolved) do
-              Moped::BSON::ObjectId.evolve(hash)
+              BSON::ObjectId.evolve(hash)
             end
 
             it "returns the hash" do
-              evolved.should eq(hash)
+              expect(evolved).to eq(hash)
             end
           end
 
@@ -313,11 +313,11 @@ describe Mongoid::Extensions::ObjectId do
             end
 
             let(:evolved) do
-              Moped::BSON::ObjectId.evolve(hash)
+              BSON::ObjectId.evolve(hash)
             end
 
             it "returns the hash" do
-              evolved.should eq(hash)
+              expect(evolved).to eq(hash)
             end
           end
         end
@@ -332,26 +332,26 @@ describe Mongoid::Extensions::ObjectId do
       context "when provided a single object id" do
 
         let(:mongoized) do
-          Moped::BSON::ObjectId.mongoize(object_id)
+          BSON::ObjectId.mongoize(object_id)
         end
 
         it "returns the object id" do
-          mongoized.should eq(object_id)
+          expect(mongoized).to eq(object_id)
         end
       end
 
       context "when provided an array of object ids" do
 
         let(:other_id) do
-          Moped::BSON::ObjectId.new
+          BSON::ObjectId.new
         end
 
         let(:mongoized) do
-          Moped::BSON::ObjectId.mongoize([ object_id, other_id ])
+          BSON::ObjectId.mongoize([ object_id, other_id ])
         end
 
         it "returns the array of object ids" do
-          mongoized.should eq([ object_id, other_id ])
+          expect(mongoized).to eq([ object_id, other_id ])
         end
       end
 
@@ -360,18 +360,18 @@ describe Mongoid::Extensions::ObjectId do
         context "when the string is a valid object id" do
 
           let(:mongoized) do
-            Moped::BSON::ObjectId.mongoize(object_id.to_s)
+            BSON::ObjectId.mongoize(object_id.to_s)
           end
 
           it "mongoizes to an object id" do
-            mongoized.should eq(object_id)
+            expect(mongoized).to eq(object_id)
           end
         end
 
         context "when the string is not a valid object id" do
 
           it "returns the key" do
-            Moped::BSON::ObjectId.mongoize(composite_key).should eq(
+            expect(BSON::ObjectId.mongoize(composite_key)).to eq(
               composite_key
             )
           end
@@ -380,11 +380,11 @@ describe Mongoid::Extensions::ObjectId do
         context "when the string is empty" do
 
           let(:mongoized) do
-            Moped::BSON::ObjectId.mongoize("")
+            BSON::ObjectId.mongoize("")
           end
 
           it "mongoizes to nil" do
-            mongoized.should be_nil
+            expect(mongoized).to be_nil
           end
         end
       end
@@ -394,22 +394,22 @@ describe Mongoid::Extensions::ObjectId do
         context "when array key of nils" do
 
           let(:mongoized) do
-            Moped::BSON::ObjectId.mongoize([ nil, nil ])
+            BSON::ObjectId.mongoize([ nil, nil ])
           end
 
           it "returns an empty array" do
-            mongoized.should be_empty
+            expect(mongoized).to be_empty
           end
         end
 
         context "when the array key is empty strings" do
 
           let(:mongoized) do
-            Moped::BSON::ObjectId.mongoize([ "", "" ])
+            BSON::ObjectId.mongoize([ "", "" ])
           end
 
           it "returns an empty array" do
-            mongoized.should be_empty
+            expect(mongoized).to be_empty
           end
         end
 
@@ -418,15 +418,15 @@ describe Mongoid::Extensions::ObjectId do
           context "when the strings are valid object ids" do
 
             let(:other_id) do
-              Moped::BSON::ObjectId.new
+              BSON::ObjectId.new
             end
 
             let(:mongoized) do
-              Moped::BSON::ObjectId.mongoize([ object_id.to_s, other_id.to_s ])
+              BSON::ObjectId.mongoize([ object_id.to_s, other_id.to_s ])
             end
 
             it "mongoizes to an array of object ids" do
-              mongoized.should eq([ object_id, other_id ])
+              expect(mongoized).to eq([ object_id, other_id ])
             end
           end
 
@@ -437,11 +437,11 @@ describe Mongoid::Extensions::ObjectId do
             end
 
             let(:mongoized) do
-              Moped::BSON::ObjectId.mongoize([ composite_key, other_key ])
+              BSON::ObjectId.mongoize([ composite_key, other_key ])
             end
 
             it "returns the key" do
-              Moped::BSON::ObjectId.mongoize(composite_key).should eq(
+              expect(BSON::ObjectId.mongoize(composite_key)).to eq(
                 composite_key
               )
             end
@@ -460,18 +460,18 @@ describe Mongoid::Extensions::ObjectId do
             end
 
             let(:mongoized) do
-              Moped::BSON::ObjectId.mongoize(hash)
+              BSON::ObjectId.mongoize(hash)
             end
 
             it "returns the hash" do
-              mongoized.should eq(hash)
+              expect(mongoized).to eq(hash)
             end
           end
 
           context "when the value is an array of object ids" do
 
             let(:other_id) do
-              Moped::BSON::ObjectId.new
+              BSON::ObjectId.new
             end
 
             let(:hash) do
@@ -479,11 +479,11 @@ describe Mongoid::Extensions::ObjectId do
             end
 
             let(:mongoized) do
-              Moped::BSON::ObjectId.mongoize(hash)
+              BSON::ObjectId.mongoize(hash)
             end
 
             it "returns the hash" do
-              mongoized.should eq(hash)
+              expect(mongoized).to eq(hash)
             end
           end
 
@@ -494,18 +494,18 @@ describe Mongoid::Extensions::ObjectId do
             end
 
             let(:mongoized) do
-              Moped::BSON::ObjectId.mongoize(hash)
+              BSON::ObjectId.mongoize(hash)
             end
 
             it "returns the hash with mongoized value" do
-              mongoized.should eq({ _id: object_id })
+              expect(mongoized).to eq({ _id: object_id })
             end
           end
 
           context "when the value is an array of strings" do
 
             let(:other_id) do
-              Moped::BSON::ObjectId.new
+              BSON::ObjectId.new
             end
 
             let(:hash) do
@@ -513,11 +513,11 @@ describe Mongoid::Extensions::ObjectId do
             end
 
             let(:mongoized) do
-              Moped::BSON::ObjectId.mongoize(hash)
+              BSON::ObjectId.mongoize(hash)
             end
 
             it "returns the hash with mongoized values" do
-              mongoized.should eq({ _id: [ object_id, other_id ] })
+              expect(mongoized).to eq({ _id: [ object_id, other_id ] })
             end
           end
         end
@@ -531,18 +531,18 @@ describe Mongoid::Extensions::ObjectId do
             end
 
             let(:mongoized) do
-              Moped::BSON::ObjectId.mongoize(hash)
+              BSON::ObjectId.mongoize(hash)
             end
 
             it "returns the hash" do
-              mongoized.should eq(hash)
+              expect(mongoized).to eq(hash)
             end
           end
 
           context "when the value is an array of object ids" do
 
             let(:other_id) do
-              Moped::BSON::ObjectId.new
+              BSON::ObjectId.new
             end
 
             let(:hash) do
@@ -550,11 +550,11 @@ describe Mongoid::Extensions::ObjectId do
             end
 
             let(:mongoized) do
-              Moped::BSON::ObjectId.mongoize(hash)
+              BSON::ObjectId.mongoize(hash)
             end
 
             it "returns the hash" do
-              mongoized.should eq(hash)
+              expect(mongoized).to eq(hash)
             end
           end
 
@@ -565,18 +565,18 @@ describe Mongoid::Extensions::ObjectId do
             end
 
             let(:mongoized) do
-              Moped::BSON::ObjectId.mongoize(hash)
+              BSON::ObjectId.mongoize(hash)
             end
 
             it "returns the hash with mongoized value" do
-              mongoized.should eq({ id: object_id })
+              expect(mongoized).to eq({ id: object_id })
             end
           end
 
           context "when the value is an array of strings" do
 
             let(:other_id) do
-              Moped::BSON::ObjectId.new
+              BSON::ObjectId.new
             end
 
             let(:hash) do
@@ -584,11 +584,11 @@ describe Mongoid::Extensions::ObjectId do
             end
 
             let(:mongoized) do
-              Moped::BSON::ObjectId.mongoize(hash)
+              BSON::ObjectId.mongoize(hash)
             end
 
             it "returns the hash with mongoized values" do
-              mongoized.should eq({ id: [ object_id, other_id ] })
+              expect(mongoized).to eq({ id: [ object_id, other_id ] })
             end
           end
         end
@@ -602,11 +602,11 @@ describe Mongoid::Extensions::ObjectId do
             end
 
             let(:mongoized) do
-              Moped::BSON::ObjectId.mongoize(hash)
+              BSON::ObjectId.mongoize(hash)
             end
 
             it "returns the hash" do
-              mongoized.should eq(hash)
+              expect(mongoized).to eq(hash)
             end
           end
 
@@ -617,11 +617,11 @@ describe Mongoid::Extensions::ObjectId do
             end
 
             let(:mongoized) do
-              Moped::BSON::ObjectId.mongoize(hash)
+              BSON::ObjectId.mongoize(hash)
             end
 
             it "returns the hash" do
-              mongoized.should eq(hash)
+              expect(mongoized).to eq(hash)
             end
           end
         end
@@ -636,26 +636,26 @@ describe Mongoid::Extensions::ObjectId do
       context "when provided a single object id" do
 
         let(:mongoized) do
-          Moped::BSON::ObjectId.mongoize(object_id)
+          BSON::ObjectId.mongoize(object_id)
         end
 
         it "returns the object id" do
-          mongoized.should eq(object_id)
+          expect(mongoized).to eq(object_id)
         end
       end
 
       context "when provided an array of object ids" do
 
         let(:other_id) do
-          Moped::BSON::ObjectId.new
+          BSON::ObjectId.new
         end
 
         let(:mongoized) do
-          Moped::BSON::ObjectId.mongoize([ object_id, other_id ])
+          BSON::ObjectId.mongoize([ object_id, other_id ])
         end
 
         it "returns the array of object ids" do
-          mongoized.should eq([ object_id, other_id ])
+          expect(mongoized).to eq([ object_id, other_id ])
         end
       end
 
@@ -664,18 +664,18 @@ describe Mongoid::Extensions::ObjectId do
         context "when the string is a valid object id" do
 
           let(:mongoized) do
-            Moped::BSON::ObjectId.mongoize(object_id.to_s)
+            BSON::ObjectId.mongoize(object_id.to_s)
           end
 
           it "mongoizes to an object id" do
-            mongoized.should eq(object_id)
+            expect(mongoized).to eq(object_id)
           end
         end
 
         context "when the string is not a valid object id" do
 
           it "returns the key" do
-            Moped::BSON::ObjectId.mongoize(composite_key).should eq(
+            expect(BSON::ObjectId.mongoize(composite_key)).to eq(
               composite_key
             )
           end
@@ -684,11 +684,11 @@ describe Mongoid::Extensions::ObjectId do
         context "when the string is empty" do
 
           let(:mongoized) do
-            Moped::BSON::ObjectId.mongoize("")
+            BSON::ObjectId.mongoize("")
           end
 
           it "mongoizes to nil" do
-            mongoized.should be_nil
+            expect(mongoized).to be_nil
           end
         end
       end
@@ -698,22 +698,22 @@ describe Mongoid::Extensions::ObjectId do
         context "when array key of nils" do
 
           let(:mongoized) do
-            Moped::BSON::ObjectId.mongoize([ nil, nil ])
+            BSON::ObjectId.mongoize([ nil, nil ])
           end
 
           it "returns an empty array" do
-            mongoized.should be_empty
+            expect(mongoized).to be_empty
           end
         end
 
         context "when the array key is empty strings" do
 
           let(:mongoized) do
-            Moped::BSON::ObjectId.mongoize([ "", "" ])
+            BSON::ObjectId.mongoize([ "", "" ])
           end
 
           it "returns an empty array" do
-            mongoized.should be_empty
+            expect(mongoized).to be_empty
           end
         end
 
@@ -722,15 +722,15 @@ describe Mongoid::Extensions::ObjectId do
           context "when the strings are valid object ids" do
 
             let(:other_id) do
-              Moped::BSON::ObjectId.new
+              BSON::ObjectId.new
             end
 
             let(:mongoized) do
-              Moped::BSON::ObjectId.mongoize([ object_id.to_s, other_id.to_s ])
+              BSON::ObjectId.mongoize([ object_id.to_s, other_id.to_s ])
             end
 
             it "mongoizes to an array of object ids" do
-              mongoized.should eq([ object_id, other_id ])
+              expect(mongoized).to eq([ object_id, other_id ])
             end
           end
 
@@ -741,11 +741,11 @@ describe Mongoid::Extensions::ObjectId do
             end
 
             let(:mongoized) do
-              Moped::BSON::ObjectId.mongoize([ composite_key, other_key ])
+              BSON::ObjectId.mongoize([ composite_key, other_key ])
             end
 
             it "returns the key" do
-              Moped::BSON::ObjectId.mongoize(composite_key).should eq(
+              expect(BSON::ObjectId.mongoize(composite_key)).to eq(
                 composite_key
               )
             end
@@ -764,18 +764,18 @@ describe Mongoid::Extensions::ObjectId do
             end
 
             let(:mongoized) do
-              Moped::BSON::ObjectId.mongoize(hash)
+              BSON::ObjectId.mongoize(hash)
             end
 
             it "returns the hash" do
-              mongoized.should eq(hash)
+              expect(mongoized).to eq(hash)
             end
           end
 
           context "when the value is an array of object ids" do
 
             let(:other_id) do
-              Moped::BSON::ObjectId.new
+              BSON::ObjectId.new
             end
 
             let(:hash) do
@@ -783,11 +783,11 @@ describe Mongoid::Extensions::ObjectId do
             end
 
             let(:mongoized) do
-              Moped::BSON::ObjectId.mongoize(hash)
+              BSON::ObjectId.mongoize(hash)
             end
 
             it "returns the hash" do
-              mongoized.should eq(hash)
+              expect(mongoized).to eq(hash)
             end
           end
 
@@ -798,18 +798,18 @@ describe Mongoid::Extensions::ObjectId do
             end
 
             let(:mongoized) do
-              Moped::BSON::ObjectId.mongoize(hash)
+              BSON::ObjectId.mongoize(hash)
             end
 
             it "returns the hash with mongoized value" do
-              mongoized.should eq({ _id: object_id })
+              expect(mongoized).to eq({ _id: object_id })
             end
           end
 
           context "when the value is an array of strings" do
 
             let(:other_id) do
-              Moped::BSON::ObjectId.new
+              BSON::ObjectId.new
             end
 
             let(:hash) do
@@ -817,11 +817,11 @@ describe Mongoid::Extensions::ObjectId do
             end
 
             let(:mongoized) do
-              Moped::BSON::ObjectId.mongoize(hash)
+              BSON::ObjectId.mongoize(hash)
             end
 
             it "returns the hash with mongoized values" do
-              mongoized.should eq({ _id: [ object_id, other_id ] })
+              expect(mongoized).to eq({ _id: [ object_id, other_id ] })
             end
           end
         end
@@ -835,18 +835,18 @@ describe Mongoid::Extensions::ObjectId do
             end
 
             let(:mongoized) do
-              Moped::BSON::ObjectId.mongoize(hash)
+              BSON::ObjectId.mongoize(hash)
             end
 
             it "returns the hash" do
-              mongoized.should eq(hash)
+              expect(mongoized).to eq(hash)
             end
           end
 
           context "when the value is an array of object ids" do
 
             let(:other_id) do
-              Moped::BSON::ObjectId.new
+              BSON::ObjectId.new
             end
 
             let(:hash) do
@@ -854,11 +854,11 @@ describe Mongoid::Extensions::ObjectId do
             end
 
             let(:mongoized) do
-              Moped::BSON::ObjectId.mongoize(hash)
+              BSON::ObjectId.mongoize(hash)
             end
 
             it "returns the hash" do
-              mongoized.should eq(hash)
+              expect(mongoized).to eq(hash)
             end
           end
 
@@ -869,18 +869,18 @@ describe Mongoid::Extensions::ObjectId do
             end
 
             let(:mongoized) do
-              Moped::BSON::ObjectId.mongoize(hash)
+              BSON::ObjectId.mongoize(hash)
             end
 
             it "returns the hash with mongoized value" do
-              mongoized.should eq({ id: object_id })
+              expect(mongoized).to eq({ id: object_id })
             end
           end
 
           context "when the value is an array of strings" do
 
             let(:other_id) do
-              Moped::BSON::ObjectId.new
+              BSON::ObjectId.new
             end
 
             let(:hash) do
@@ -888,11 +888,11 @@ describe Mongoid::Extensions::ObjectId do
             end
 
             let(:mongoized) do
-              Moped::BSON::ObjectId.mongoize(hash)
+              BSON::ObjectId.mongoize(hash)
             end
 
             it "returns the hash with mongoized values" do
-              mongoized.should eq({ id: [ object_id, other_id ] })
+              expect(mongoized).to eq({ id: [ object_id, other_id ] })
             end
           end
         end
@@ -906,11 +906,11 @@ describe Mongoid::Extensions::ObjectId do
             end
 
             let(:mongoized) do
-              Moped::BSON::ObjectId.mongoize(hash)
+              BSON::ObjectId.mongoize(hash)
             end
 
             it "returns the hash" do
-              mongoized.should eq(hash)
+              expect(mongoized).to eq(hash)
             end
           end
 
@@ -921,11 +921,11 @@ describe Mongoid::Extensions::ObjectId do
             end
 
             let(:mongoized) do
-              Moped::BSON::ObjectId.mongoize(hash)
+              BSON::ObjectId.mongoize(hash)
             end
 
             it "returns the hash" do
-              mongoized.should eq(hash)
+              expect(mongoized).to eq(hash)
             end
           end
         end
@@ -936,11 +936,11 @@ describe Mongoid::Extensions::ObjectId do
   describe "#__mongoize_object_id__" do
 
     it "returns self" do
-      object_id.__mongoize_object_id__.should eq(object_id)
+      expect(object_id.__mongoize_object_id__).to eq(object_id)
     end
 
     it "returns the same instance" do
-      object_id.__mongoize_object_id__.should equal(object_id)
+      expect(object_id.__mongoize_object_id__).to equal(object_id)
     end
   end
 end