mongoid_heroku_stable 4.0.0

data/spec/mongoid/extensions/integer_spec.rb

@@ -0,0 +1,136 @@
+require "spec_helper"
+
+describe Mongoid::Extensions::Integer do
+
+  let(:number) do
+    118347652312341
+  end
+
+  describe "#__mongoize_time__" do
+
+    let(:integer) do
+      1335532685
+    end
+
+    let(:mongoized) do
+      integer.__mongoize_time__
+    end
+
+    it "returns the float as a time" do
+      expect(mongoized).to eq(Time.at(integer))
+    end
+  end
+
+  describe ".demongoize" do
+
+    context "when the the value is an integer" do
+
+      it "returns a integer" do
+        expect(Integer.demongoize(number)).to eq(number)
+      end
+    end
+
+    context "when the value is nil" do
+
+      it "returns nil" do
+        expect(Integer.demongoize(nil)).to be_nil
+      end
+    end
+
+    context "when the value is not an integer" do
+
+      it "converts the value to an integer" do
+        expect(Integer.demongoize("1.0")).to eq(1)
+      end
+    end
+  end
+
+  describe ".mongoize" do
+
+    context "when the value is a number" do
+
+      context "when the value is an integer" do
+
+        context "when the value is small" do
+
+          it "it returns the integer" do
+            expect(Integer.mongoize(3)).to eq(3)
+          end
+        end
+
+        context "when the value is large" do
+
+          it "returns the integer" do
+            expect(Integer.mongoize(1024**2).to_s).to eq("1048576")
+          end
+        end
+      end
+
+      context "when the value is a decimal" do
+
+        it "casts to integer" do
+          expect(Integer.mongoize(2.5)).to eq(2)
+        end
+      end
+
+      context "when the value is floating point zero" do
+
+        it "returns the integer zero" do
+          expect(Integer.mongoize(0.00000)).to eq(0)
+        end
+      end
+
+      context "when the value is a floating point integer" do
+
+        it "returns the integer number" do
+          expect(Integer.mongoize(4.00000)).to eq(4)
+        end
+      end
+
+      context "when the value has leading zeros" do
+
+        it "returns the stripped integer" do
+          expect(Integer.mongoize("000011")).to eq(11)
+        end
+      end
+    end
+
+    context "when the string is not a number" do
+
+      context "when the string is non numerical" do
+
+        it "returns 0" do
+          expect(Integer.mongoize("foo")).to eq(0)
+        end
+      end
+
+      context "when the string is numerical" do
+
+        it "returns the integer value for the string" do
+          expect(Integer.mongoize("3")).to eq(3)
+        end
+      end
+
+      context "when the string is empty" do
+
+        it "returns nil" do
+          expect(Integer.mongoize("")).to be_nil
+        end
+      end
+
+      context "when the string is nil" do
+
+        it "returns nil" do
+          expect(Integer.mongoize(nil)).to be_nil
+        end
+      end
+    end
+  end
+
+  describe "#mongoize" do
+
+    it "returns self" do
+      expect(number.mongoize).to eq(number)
+    end
+  end
+end

data/spec/mongoid/extensions/module_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+
+describe Mongoid::Extensions::Module do
+
+  describe "#re_define_method" do
+
+    context "when the method already exists" do
+
+      class Smoochy
+        def sing
+          "singing"
+        end
+      end
+
+      before do
+        Smoochy.re_define_method("sing") do
+          "singing again"
+        end
+      end
+
+      it "redefines the existing method" do
+        expect(Smoochy.new.sing).to eq("singing again")
+      end
+    end
+
+    context "when the method does not exist" do
+
+      class Rhino
+      end
+
+      before do
+        Rhino.re_define_method("sing") do
+          "singing"
+        end
+      end
+
+      it "redefines the existing method" do
+        expect(Rhino.new.sing).to eq("singing")
+      end
+    end
+  end
+end

data/spec/mongoid/extensions/nil_class_spec.rb

@@ -0,0 +1,11 @@
+require "spec_helper"
+
+describe Mongoid::Extensions::NilClass do
+
+  describe "#collectionize" do
+
+    it "returns ''" do
+      expect(nil.collectionize).to be_empty
+    end
+  end
+end

data/spec/mongoid/extensions/object_id_spec.rb

@@ -0,0 +1,946 @@
+require "spec_helper"
+
+describe Mongoid::Extensions::ObjectId do
+
+  let(:object_id) do
+    Moped::BSON::ObjectId.new
+  end
+
+  let(:composite_key) do
+    "21-jump-street"
+  end
+
+  describe "#__evolve_object_id__" do
+
+    it "returns self" do
+      expect(object_id.__evolve_object_id__).to eq(object_id)
+    end
+
+    it "returns the same instance" do
+      expect(object_id.__evolve_object_id__).to equal(object_id)
+    end
+  end
+
+  describe ".evolve" do
+
+    context "when the class is using object ids" do
+
+      context "when provided a single object id" do
+
+        let(:evolved) do
+          Moped::BSON::ObjectId.evolve(object_id)
+        end
+
+        it "returns the object id" do
+          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
+        end
+
+        let(:evolved) do
+          Moped::BSON::ObjectId.evolve([ object_id, other_id ])
+        end
+
+        it "returns the array of object ids" do
+          expect(evolved).to eq([ object_id, other_id ])
+        end
+      end
+
+      context "when provided a single string" do
+
+        context "when the string is a valid object id" do
+
+          let(:evolved) do
+            Moped::BSON::ObjectId.evolve(object_id.to_s)
+          end
+
+          it "evolves to an object id" do
+            expect(evolved).to eq(object_id)
+          end
+        end
+
+        context "when the string is not a valid object id" do
+
+          it "returns the key" do
+            expect(Moped::BSON::ObjectId.evolve(composite_key)).to eq(
+              composite_key
+            )
+          end
+        end
+
+        context "when the string is empty" do
+
+          let(:evolved) do
+            Moped::BSON::ObjectId.evolve("")
+          end
+
+          it "evolves to an empty string" do
+            expect(evolved).to be_empty
+          end
+        end
+      end
+
+      context "when provided an array" do
+
+        context "when array key of nils" do
+
+          let(:evolved) do
+            Moped::BSON::ObjectId.evolve([ nil, nil ])
+          end
+
+          it "returns the array with nils" do
+            expect(evolved).to eq([ nil, nil ])
+          end
+        end
+
+        context "when the array key is empty strings" do
+
+          let(:evolved) do
+            Moped::BSON::ObjectId.evolve([ "", "" ])
+          end
+
+          it "returns the array with empty strings" do
+            expect(evolved).to eq([ "", "" ])
+          end
+        end
+
+        context "when the array key is full of strings" do
+
+          context "when the strings are valid object ids" do
+
+            let(:other_id) do
+              Moped::BSON::ObjectId.new
+            end
+
+            let(:evolved) do
+              Moped::BSON::ObjectId.evolve([ object_id.to_s, other_id.to_s ])
+            end
+
+            it "evolves to an array of object ids" do
+              expect(evolved).to eq([ object_id, other_id ])
+            end
+          end
+
+          context "when the strings are not valid object ids" do
+
+            let(:other_key) do
+              "hawaii-five-o"
+            end
+
+            let(:evolved) do
+              Moped::BSON::ObjectId.evolve([ composite_key, other_key ])
+            end
+
+            it "returns the key" do
+              expect(Moped::BSON::ObjectId.evolve(composite_key)).to eq(
+                composite_key
+              )
+            end
+          end
+        end
+      end
+
+      context "when provided a hash" do
+
+        context "when the hash key is _id" do
+
+          context "when the value is an object id" do
+
+            let(:hash) do
+              { _id: object_id }
+            end
+
+            let(:evolved) do
+              Moped::BSON::ObjectId.evolve(hash)
+            end
+
+            it "returns the hash" do
+              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
+            end
+
+            let(:hash) do
+              { _id: [ object_id, other_id ] }
+            end
+
+            let(:evolved) do
+              Moped::BSON::ObjectId.evolve(hash)
+            end
+
+            it "returns the hash" do
+              expect(evolved).to eq(hash)
+            end
+          end
+
+          context "when the value is a string" do
+
+            let(:hash) do
+              { _id: object_id.to_s }
+            end
+
+            let(:evolved) do
+              Moped::BSON::ObjectId.evolve(hash)
+            end
+
+            it "returns the hash with evolved value" do
+              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
+            end
+
+            let(:hash) do
+              { _id: [ object_id.to_s, other_id.to_s ] }
+            end
+
+            let(:evolved) do
+              Moped::BSON::ObjectId.evolve(hash)
+            end
+
+            it "returns the hash with evolved values" do
+              expect(evolved).to eq({ _id: [ object_id, other_id ] })
+            end
+          end
+        end
+
+        context "when the hash key is id" do
+
+          context "when the value is an object id" do
+
+            let(:hash) do
+              { id: object_id }
+            end
+
+            let(:evolved) do
+              Moped::BSON::ObjectId.evolve(hash)
+            end
+
+            it "returns the hash" do
+              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
+            end
+
+            let(:hash) do
+              { id: [ object_id, other_id ] }
+            end
+
+            let(:evolved) do
+              Moped::BSON::ObjectId.evolve(hash)
+            end
+
+            it "returns the hash" do
+              expect(evolved).to eq(hash)
+            end
+          end
+
+          context "when the value is a string" do
+
+            let(:hash) do
+              { id: object_id.to_s }
+            end
+
+            let(:evolved) do
+              Moped::BSON::ObjectId.evolve(hash)
+            end
+
+            it "returns the hash with evolved value" do
+              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
+            end
+
+            let(:hash) do
+              { id: [ object_id.to_s, other_id.to_s ] }
+            end
+
+            let(:evolved) do
+              Moped::BSON::ObjectId.evolve(hash)
+            end
+
+            it "returns the hash with evolved values" do
+              expect(evolved).to eq({ id: [ object_id, other_id ] })
+            end
+          end
+        end
+
+        context "when the hash key is not an id" do
+
+          context "when the value is a string" do
+
+            let(:hash) do
+              { key: composite_key }
+            end
+
+            let(:evolved) do
+              Moped::BSON::ObjectId.evolve(hash)
+            end
+
+            it "returns the hash" do
+              expect(evolved).to eq(hash)
+            end
+          end
+
+          context "when the value is an array of strings" do
+
+            let(:hash) do
+              { key: [ composite_key ] }
+            end
+
+            let(:evolved) do
+              Moped::BSON::ObjectId.evolve(hash)
+            end
+
+            it "returns the hash" do
+              expect(evolved).to eq(hash)
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe ".mongoize" do
+
+    context "when the class is using object ids" do
+
+      context "when provided a single object id" do
+
+        let(:mongoized) do
+          Moped::BSON::ObjectId.mongoize(object_id)
+        end
+
+        it "returns the object id" do
+          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
+        end
+
+        let(:mongoized) do
+          Moped::BSON::ObjectId.mongoize([ object_id, other_id ])
+        end
+
+        it "returns the array of object ids" do
+          expect(mongoized).to eq([ object_id, other_id ])
+        end
+      end
+
+      context "when provided a single string" do
+
+        context "when the string is a valid object id" do
+
+          let(:mongoized) do
+            Moped::BSON::ObjectId.mongoize(object_id.to_s)
+          end
+
+          it "mongoizes to an object id" do
+            expect(mongoized).to eq(object_id)
+          end
+        end
+
+        context "when the string is not a valid object id" do
+
+          it "returns the key" do
+            expect(Moped::BSON::ObjectId.mongoize(composite_key)).to eq(
+              composite_key
+            )
+          end
+        end
+
+        context "when the string is empty" do
+
+          let(:mongoized) do
+            Moped::BSON::ObjectId.mongoize("")
+          end
+
+          it "mongoizes to nil" do
+            expect(mongoized).to be_nil
+          end
+        end
+      end
+
+      context "when provided an array" do
+
+        context "when array key of nils" do
+
+          let(:mongoized) do
+            Moped::BSON::ObjectId.mongoize([ nil, nil ])
+          end
+
+          it "returns an empty array" do
+            expect(mongoized).to be_empty
+          end
+        end
+
+        context "when the array key is empty strings" do
+
+          let(:mongoized) do
+            Moped::BSON::ObjectId.mongoize([ "", "" ])
+          end
+
+          it "returns an empty array" do
+            expect(mongoized).to be_empty
+          end
+        end
+
+        context "when the array key is full of strings" do
+
+          context "when the strings are valid object ids" do
+
+            let(:other_id) do
+              Moped::BSON::ObjectId.new
+            end
+
+            let(:mongoized) do
+              Moped::BSON::ObjectId.mongoize([ object_id.to_s, other_id.to_s ])
+            end
+
+            it "mongoizes to an array of object ids" do
+              expect(mongoized).to eq([ object_id, other_id ])
+            end
+          end
+
+          context "when the strings are not valid object ids" do
+
+            let(:other_key) do
+              "hawaii-five-o"
+            end
+
+            let(:mongoized) do
+              Moped::BSON::ObjectId.mongoize([ composite_key, other_key ])
+            end
+
+            it "returns the key" do
+              expect(Moped::BSON::ObjectId.mongoize(composite_key)).to eq(
+                composite_key
+              )
+            end
+          end
+        end
+      end
+
+      context "when provided a hash" do
+
+        context "when the hash key is _id" do
+
+          context "when the value is an object id" do
+
+            let(:hash) do
+              { _id: object_id }
+            end
+
+            let(:mongoized) do
+              Moped::BSON::ObjectId.mongoize(hash)
+            end
+
+            it "returns the hash" do
+              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
+            end
+
+            let(:hash) do
+              { _id: [ object_id, other_id ] }
+            end
+
+            let(:mongoized) do
+              Moped::BSON::ObjectId.mongoize(hash)
+            end
+
+            it "returns the hash" do
+              expect(mongoized).to eq(hash)
+            end
+          end
+
+          context "when the value is a string" do
+
+            let(:hash) do
+              { _id: object_id.to_s }
+            end
+
+            let(:mongoized) do
+              Moped::BSON::ObjectId.mongoize(hash)
+            end
+
+            it "returns the hash with mongoized value" do
+              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
+            end
+
+            let(:hash) do
+              { _id: [ object_id.to_s, other_id.to_s ] }
+            end
+
+            let(:mongoized) do
+              Moped::BSON::ObjectId.mongoize(hash)
+            end
+
+            it "returns the hash with mongoized values" do
+              expect(mongoized).to eq({ _id: [ object_id, other_id ] })
+            end
+          end
+        end
+
+        context "when the hash key is id" do
+
+          context "when the value is an object id" do
+
+            let(:hash) do
+              { id: object_id }
+            end
+
+            let(:mongoized) do
+              Moped::BSON::ObjectId.mongoize(hash)
+            end
+
+            it "returns the hash" do
+              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
+            end
+
+            let(:hash) do
+              { id: [ object_id, other_id ] }
+            end
+
+            let(:mongoized) do
+              Moped::BSON::ObjectId.mongoize(hash)
+            end
+
+            it "returns the hash" do
+              expect(mongoized).to eq(hash)
+            end
+          end
+
+          context "when the value is a string" do
+
+            let(:hash) do
+              { id: object_id.to_s }
+            end
+
+            let(:mongoized) do
+              Moped::BSON::ObjectId.mongoize(hash)
+            end
+
+            it "returns the hash with mongoized value" do
+              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
+            end
+
+            let(:hash) do
+              { id: [ object_id.to_s, other_id.to_s ] }
+            end
+
+            let(:mongoized) do
+              Moped::BSON::ObjectId.mongoize(hash)
+            end
+
+            it "returns the hash with mongoized values" do
+              expect(mongoized).to eq({ id: [ object_id, other_id ] })
+            end
+          end
+        end
+
+        context "when the hash key is not an id" do
+
+          context "when the value is a string" do
+
+            let(:hash) do
+              { key: composite_key }
+            end
+
+            let(:mongoized) do
+              Moped::BSON::ObjectId.mongoize(hash)
+            end
+
+            it "returns the hash" do
+              expect(mongoized).to eq(hash)
+            end
+          end
+
+          context "when the value is an array of strings" do
+
+            let(:hash) do
+              { key: [ composite_key ] }
+            end
+
+            let(:mongoized) do
+              Moped::BSON::ObjectId.mongoize(hash)
+            end
+
+            it "returns the hash" do
+              expect(mongoized).to eq(hash)
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe ".mongoize" do
+
+    context "when the class is using object ids" do
+
+      context "when provided a single object id" do
+
+        let(:mongoized) do
+          Moped::BSON::ObjectId.mongoize(object_id)
+        end
+
+        it "returns the object id" do
+          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
+        end
+
+        let(:mongoized) do
+          Moped::BSON::ObjectId.mongoize([ object_id, other_id ])
+        end
+
+        it "returns the array of object ids" do
+          expect(mongoized).to eq([ object_id, other_id ])
+        end
+      end
+
+      context "when provided a single string" do
+
+        context "when the string is a valid object id" do
+
+          let(:mongoized) do
+            Moped::BSON::ObjectId.mongoize(object_id.to_s)
+          end
+
+          it "mongoizes to an object id" do
+            expect(mongoized).to eq(object_id)
+          end
+        end
+
+        context "when the string is not a valid object id" do
+
+          it "returns the key" do
+            expect(Moped::BSON::ObjectId.mongoize(composite_key)).to eq(
+              composite_key
+            )
+          end
+        end
+
+        context "when the string is empty" do
+
+          let(:mongoized) do
+            Moped::BSON::ObjectId.mongoize("")
+          end
+
+          it "mongoizes to nil" do
+            expect(mongoized).to be_nil
+          end
+        end
+      end
+
+      context "when provided an array" do
+
+        context "when array key of nils" do
+
+          let(:mongoized) do
+            Moped::BSON::ObjectId.mongoize([ nil, nil ])
+          end
+
+          it "returns an empty array" do
+            expect(mongoized).to be_empty
+          end
+        end
+
+        context "when the array key is empty strings" do
+
+          let(:mongoized) do
+            Moped::BSON::ObjectId.mongoize([ "", "" ])
+          end
+
+          it "returns an empty array" do
+            expect(mongoized).to be_empty
+          end
+        end
+
+        context "when the array key is full of strings" do
+
+          context "when the strings are valid object ids" do
+
+            let(:other_id) do
+              Moped::BSON::ObjectId.new
+            end
+
+            let(:mongoized) do
+              Moped::BSON::ObjectId.mongoize([ object_id.to_s, other_id.to_s ])
+            end
+
+            it "mongoizes to an array of object ids" do
+              expect(mongoized).to eq([ object_id, other_id ])
+            end
+          end
+
+          context "when the strings are not valid object ids" do
+
+            let(:other_key) do
+              "hawaii-five-o"
+            end
+
+            let(:mongoized) do
+              Moped::BSON::ObjectId.mongoize([ composite_key, other_key ])
+            end
+
+            it "returns the key" do
+              expect(Moped::BSON::ObjectId.mongoize(composite_key)).to eq(
+                composite_key
+              )
+            end
+          end
+        end
+      end
+
+      context "when provided a hash" do
+
+        context "when the hash key is _id" do
+
+          context "when the value is an object id" do
+
+            let(:hash) do
+              { _id: object_id }
+            end
+
+            let(:mongoized) do
+              Moped::BSON::ObjectId.mongoize(hash)
+            end
+
+            it "returns the hash" do
+              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
+            end
+
+            let(:hash) do
+              { _id: [ object_id, other_id ] }
+            end
+
+            let(:mongoized) do
+              Moped::BSON::ObjectId.mongoize(hash)
+            end
+
+            it "returns the hash" do
+              expect(mongoized).to eq(hash)
+            end
+          end
+
+          context "when the value is a string" do
+
+            let(:hash) do
+              { _id: object_id.to_s }
+            end
+
+            let(:mongoized) do
+              Moped::BSON::ObjectId.mongoize(hash)
+            end
+
+            it "returns the hash with mongoized value" do
+              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
+            end
+
+            let(:hash) do
+              { _id: [ object_id.to_s, other_id.to_s ] }
+            end
+
+            let(:mongoized) do
+              Moped::BSON::ObjectId.mongoize(hash)
+            end
+
+            it "returns the hash with mongoized values" do
+              expect(mongoized).to eq({ _id: [ object_id, other_id ] })
+            end
+          end
+        end
+
+        context "when the hash key is id" do
+
+          context "when the value is an object id" do
+
+            let(:hash) do
+              { id: object_id }
+            end
+
+            let(:mongoized) do
+              Moped::BSON::ObjectId.mongoize(hash)
+            end
+
+            it "returns the hash" do
+              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
+            end
+
+            let(:hash) do
+              { id: [ object_id, other_id ] }
+            end
+
+            let(:mongoized) do
+              Moped::BSON::ObjectId.mongoize(hash)
+            end
+
+            it "returns the hash" do
+              expect(mongoized).to eq(hash)
+            end
+          end
+
+          context "when the value is a string" do
+
+            let(:hash) do
+              { id: object_id.to_s }
+            end
+
+            let(:mongoized) do
+              Moped::BSON::ObjectId.mongoize(hash)
+            end
+
+            it "returns the hash with mongoized value" do
+              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
+            end
+
+            let(:hash) do
+              { id: [ object_id.to_s, other_id.to_s ] }
+            end
+
+            let(:mongoized) do
+              Moped::BSON::ObjectId.mongoize(hash)
+            end
+
+            it "returns the hash with mongoized values" do
+              expect(mongoized).to eq({ id: [ object_id, other_id ] })
+            end
+          end
+        end
+
+        context "when the hash key is not an id" do
+
+          context "when the value is a string" do
+
+            let(:hash) do
+              { key: composite_key }
+            end
+
+            let(:mongoized) do
+              Moped::BSON::ObjectId.mongoize(hash)
+            end
+
+            it "returns the hash" do
+              expect(mongoized).to eq(hash)
+            end
+          end
+
+          context "when the value is an array of strings" do
+
+            let(:hash) do
+              { key: [ composite_key ] }
+            end
+
+            let(:mongoized) do
+              Moped::BSON::ObjectId.mongoize(hash)
+            end
+
+            it "returns the hash" do
+              expect(mongoized).to eq(hash)
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe "#__mongoize_object_id__" do
+
+    it "returns self" do
+      expect(object_id.__mongoize_object_id__).to eq(object_id)
+    end
+
+    it "returns the same instance" do
+      expect(object_id.__mongoize_object_id__).to equal(object_id)
+    end
+  end
+end