mongoid 3.1.5 → 8.0.2

data/spec/mongoid/extensions/object_id_spec.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 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 +15,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 +30,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 +58,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 +78,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 +92,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 +116,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 +135,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 +158,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 +177,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 +192,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 +211,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 +229,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 +248,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 +263,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 +282,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 +300,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 +315,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 +334,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 +362,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 +382,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 +396,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 +420,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 +439,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 +462,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 +481,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 +496,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 +515,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 +533,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 +552,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 +567,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 +586,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 +604,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 +619,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 +638,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 +666,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 +686,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 +700,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 +724,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 +743,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 +766,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 +785,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 +800,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 +819,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 +837,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 +856,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 +871,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 +890,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 +908,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 +923,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 +938,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