mongoid 3.1.4 → 3.1.5

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
+      mongoized.should eq(Time.at(integer))
+    end
+  end
+
+  describe ".demongoize" do
+
+    context "when the the value is an integer" do
+
+      it "returns a integer" do
+        Integer.demongoize(number).should eq(number)
+      end
+    end
+
+    context "when the value is nil" do
+
+      it "returns nil" do
+        Integer.demongoize(nil).should be_nil
+      end
+    end
+
+    context "when the value is not an integer" do
+
+      it "converts the value to an integer" do
+        Integer.demongoize("1.0").should 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
+            Integer.mongoize(3).should eq(3)
+          end
+        end
+
+        context "when the value is large" do
+
+          it "returns the integer" do
+            Integer.mongoize(1024**2).to_s.should eq("1048576")
+          end
+        end
+      end
+
+      context "when the value is a decimal" do
+
+        it "casts to integer" do
+          Integer.mongoize(2.5).should eq(2)
+        end
+      end
+
+      context "when the value is floating point zero" do
+
+        it "returns the integer zero" do
+          Integer.mongoize(0.00000).should eq(0)
+        end
+      end
+
+      context "when the value is a floating point integer" do
+
+        it "returns the integer number" do
+          Integer.mongoize(4.00000).should eq(4)
+        end
+      end
+
+      context "when the value has leading zeros" do
+
+        it "returns the stripped integer" do
+          Integer.mongoize("000011").should 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
+          Integer.mongoize("foo").should eq(0)
+        end
+      end
+
+      context "when the string is numerical" do
+
+        it "returns the integer value for the string" do
+          Integer.mongoize("3").should eq(3)
+        end
+      end
+
+      context "when the string is empty" do
+
+        it "returns nil" do
+          Integer.mongoize("").should be_nil
+        end
+      end
+
+      context "when the string is nil" do
+
+        it "returns nil" do
+          Integer.mongoize(nil).should be_nil
+        end
+      end
+    end
+  end
+
+  describe "#mongoize" do
+
+    it "returns self" do
+      number.mongoize.should 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
+        Smoochy.new.sing.should 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
+        Rhino.new.sing.should 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
+      nil.collectionize.should 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
+      object_id.__evolve_object_id__.should eq(object_id)
+    end
+
+    it "returns the same instance" do
+      object_id.__evolve_object_id__.should 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
+          evolved.should 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
+          evolved.should 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
+            evolved.should 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(
+              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
+            evolved.should 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
+            evolved.should 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
+            evolved.should 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
+              evolved.should 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
+              Moped::BSON::ObjectId.evolve(composite_key).should 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
+              evolved.should 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
+              evolved.should 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
+              evolved.should 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
+              evolved.should 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
+              evolved.should 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
+              evolved.should 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
+              evolved.should 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
+              evolved.should 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
+              evolved.should 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
+              evolved.should 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
+          mongoized.should 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
+          mongoized.should 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
+            mongoized.should 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(
+              composite_key
+            )
+          end
+        end
+
+        context "when the string is empty" do
+
+          let(:mongoized) do
+            Moped::BSON::ObjectId.mongoize("")
+          end
+
+          it "mongoizes to nil" do
+            mongoized.should 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
+            mongoized.should 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
+            mongoized.should 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
+              mongoized.should 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
+              Moped::BSON::ObjectId.mongoize(composite_key).should 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
+              mongoized.should 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
+              mongoized.should 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
+              mongoized.should 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
+              mongoized.should 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
+              mongoized.should 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
+              mongoized.should 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
+              mongoized.should 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
+              mongoized.should 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
+              mongoized.should 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
+              mongoized.should 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
+          mongoized.should 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
+          mongoized.should 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
+            mongoized.should 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(
+              composite_key
+            )
+          end
+        end
+
+        context "when the string is empty" do
+
+          let(:mongoized) do
+            Moped::BSON::ObjectId.mongoize("")
+          end
+
+          it "mongoizes to nil" do
+            mongoized.should 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
+            mongoized.should 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
+            mongoized.should 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
+              mongoized.should 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
+              Moped::BSON::ObjectId.mongoize(composite_key).should 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
+              mongoized.should 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
+              mongoized.should 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
+              mongoized.should 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
+              mongoized.should 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
+              mongoized.should 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
+              mongoized.should 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
+              mongoized.should 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
+              mongoized.should 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
+              mongoized.should 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
+              mongoized.should eq(hash)
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe "#__mongoize_object_id__" do
+
+    it "returns self" do
+      object_id.__mongoize_object_id__.should eq(object_id)
+    end
+
+    it "returns the same instance" do
+      object_id.__mongoize_object_id__.should equal(object_id)
+    end
+  end
+end