mongoid 3.1.4 → 3.1.5

data/spec/mongoid/extensions/date_time_spec.rb

@@ -0,0 +1,155 @@
+require "spec_helper"
+
+describe Mongoid::Extensions::DateTime do
+
+  describe "__mongoize_time__" do
+
+    context "when the date time has more than seconds precision" do
+
+      let(:date_time) do
+        DateTime.parse("2012-06-17 18:42:15.123Z")
+      end
+
+      let(:mongoized) do
+        date_time.__mongoize_time__
+      end
+
+      it "does not drop the precision" do
+        mongoized.to_f.to_s.should match(/\.123/)
+      end
+    end
+
+    context "when using active support's time zone" do
+
+      before do
+        Mongoid.use_activesupport_time_zone = true
+        Time.zone = "Tokyo"
+      end
+
+      after do
+        Time.zone = nil
+      end
+
+      let(:date_time) do
+        DateTime.new(2010, 1, 1)
+      end
+
+      let(:expected) do
+        Time.zone.local(2010, 1, 1, 9, 0, 0, 0)
+      end
+
+      let(:mongoized) do
+        date_time.__mongoize_time__
+      end
+
+      it "returns the date as a local time" do
+        mongoized.should eq(expected)
+      end
+    end
+
+    context "when not using active support's time zone" do
+
+      before do
+        Mongoid.use_activesupport_time_zone = false
+      end
+
+      after do
+        Mongoid.use_activesupport_time_zone = true
+        Time.zone = nil
+      end
+
+      let(:date_time) do
+        DateTime.new(2010, 1, 1)
+      end
+
+      let(:expected) do
+        Time.utc(2010, 1, 1, 0, 0, 0, 0).getlocal
+      end
+
+      let(:mongoized) do
+        date_time.__mongoize_time__
+      end
+
+      it "returns the date as a utc time" do
+        mongoized.should eq(expected)
+      end
+    end
+  end
+
+  describe ".demongoize" do
+
+    let!(:time) do
+      Time.now.utc
+    end
+
+    let(:date_time) do
+      DateTime.demongoize(time)
+    end
+
+    it "converts to a datetime" do
+      date_time.should be_kind_of(DateTime)
+    end
+
+    it "does not change the time" do
+      DateTime.demongoize(time).should eq(time)
+    end
+
+    context "when using utc" do
+
+      before do
+        Mongoid.use_utc = true
+      end
+
+      after do
+        Mongoid.use_utc = false
+      end
+
+      context "when setting a utc time" do
+
+        let(:user) do
+          User.new
+        end
+
+        let(:date) do
+          DateTime.parse("2012-01-23 08:26:14 PM")
+        end
+
+        before do
+          user.last_login = date
+        end
+
+        it "does not return the time with time zone applied" do
+          user.last_login.should eq(date)
+        end
+      end
+    end
+  end
+
+  describe ".mongoize" do
+
+    context "when the string is an invalid time" do
+
+      let(:epoch) do
+        Time.utc(1970, 1, 1, 0, 0, 0, 0)
+      end
+
+      it "returns epoch" do
+        DateTime.mongoize("time").should eq(epoch)
+      end
+    end
+  end
+
+  describe "#mongoize" do
+
+    let!(:date_time) do
+      Time.now.utc.to_datetime
+    end
+
+    context "when the string is an invalid time" do
+
+      it "returns the date time as a time" do
+        date_time.mongoize.should be_a(Time)
+      end
+    end
+  end
+end

data/spec/mongoid/extensions/false_class_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+
+describe Mongoid::Extensions::FalseClass do
+
+  describe "#__sortable__" do
+
+    it "returns 0" do
+      false.__sortable__.should eq(0)
+    end
+  end
+
+  describe "#is_a?" do
+
+    context "when provided a Boolean" do
+
+      it "returns true" do
+        false.is_a?(Boolean).should be_true
+      end
+    end
+
+    context "when provided a FalseClass" do
+
+      it "returns true" do
+        false.is_a?(FalseClass).should be_true
+      end
+    end
+
+    context "when provided a TrueClass" do
+
+      it "returns false" do
+        false.is_a?(TrueClass).should be_false
+      end
+    end
+
+    context "when provided an invalid class" do
+
+      it "returns false" do
+        false.is_a?(String).should be_false
+      end
+    end
+  end
+end

data/spec/mongoid/extensions/float_spec.rb

@@ -0,0 +1,133 @@
+require "spec_helper"
+
+describe Mongoid::Extensions::Float do
+
+  let(:number) do
+    118.345
+  end
+
+  describe "#__mongoize_time__" do
+
+    let(:float) do
+      1335532685.117847
+    end
+
+    let(:mongoized) do
+      float.__mongoize_time__
+    end
+
+    it "returns the float as a time" do
+      mongoized.should eq(Time.at(float))
+    end
+  end
+
+  describe ".demongoize" do
+
+    context "when the the value is a float" do
+
+      it "returns a float" do
+        Float.demongoize(number).should eq(number)
+      end
+    end
+
+    context "when the value is nil" do
+
+      it "returns nil" do
+        Float.demongoize(nil).should be_nil
+      end
+    end
+  end
+
+  describe ".mongoize" do
+
+    context "when the value is a number" do
+
+      context "when the value is an float" do
+
+        context "when the value is small" do
+
+          it "it returns the float" do
+            Float.mongoize(3).should eq(3)
+          end
+
+          it "returns the number as type float" do
+            Float.mongoize(3).should be_a(Float)
+          end
+        end
+
+        context "when the value is large" do
+
+          it "returns the float" do
+            Float.mongoize(1024**2).to_s.should eq("1048576.0")
+          end
+        end
+      end
+
+      context "when the value is a decimal" do
+
+        it "casts to float" do
+          Float.mongoize(2.5).should eq(2.5)
+        end
+      end
+
+      context "when the value is floating point zero" do
+
+        it "returns the float zero" do
+          Float.mongoize(0.00000).should eq(0)
+        end
+      end
+
+      context "when the value is a floating point float" do
+
+        it "returns the float number" do
+          Float.mongoize(4.00000).should eq(4)
+        end
+      end
+
+      context "when the value has leading zeros" do
+
+        it "returns the stripped float" do
+          Float.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
+          Float.mongoize("foo").should eq(0.0)
+        end
+      end
+
+      context "when the string is numerical" do
+
+        it "returns the float value for the string" do
+          Float.mongoize("3").should eq(3)
+        end
+      end
+
+      context "when the string is empty" do
+
+        it "returns nil" do
+          Float.mongoize("").should be_nil
+        end
+      end
+
+      context "when the string is nil" do
+
+        it "returns nil" do
+          Float.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/hash_spec.rb

@@ -0,0 +1,333 @@
+require "spec_helper"
+
+describe Mongoid::Extensions::Hash do
+
+  describe "#__evolve_object_id__" do
+
+    context "when values have object id strings" do
+
+      let(:object_id) do
+        Moped::BSON::ObjectId.new
+      end
+
+      let(:hash) do
+        { field: object_id.to_s }
+      end
+
+      let(:evolved) do
+        hash.__evolve_object_id__
+      end
+
+      it "converts each value in the hash" do
+        evolved[:field].should eq(object_id)
+      end
+    end
+
+    context "when values have object ids" do
+
+      let(:object_id) do
+        Moped::BSON::ObjectId.new
+      end
+
+      let(:hash) do
+        { field: object_id }
+      end
+
+      let(:evolved) do
+        hash.__evolve_object_id__
+      end
+
+      it "converts each value in the hash" do
+        evolved[:field].should eq(object_id)
+      end
+    end
+
+    context "when values have empty strings" do
+
+      let(:object_id) do
+        Moped::BSON::ObjectId.new
+      end
+
+      let(:hash) do
+        { field: "" }
+      end
+
+      let(:evolved) do
+        hash.__evolve_object_id__
+      end
+
+      it "retains the empty string values" do
+        evolved[:field].should be_empty
+      end
+    end
+
+    context "when values have nils" do
+
+      let(:object_id) do
+        Moped::BSON::ObjectId.new
+      end
+
+      let(:hash) do
+        { field: nil }
+      end
+
+      let(:evolved) do
+        hash.__evolve_object_id__
+      end
+
+      it "retains the nil values" do
+        evolved[:field].should be_nil
+      end
+    end
+  end
+
+  describe "#__mongoize_object_id__" do
+
+    context "when values have object id strings" do
+
+      let(:object_id) do
+        Moped::BSON::ObjectId.new
+      end
+
+      let(:hash) do
+        { field: object_id.to_s }
+      end
+
+      let(:mongoized) do
+        hash.__mongoize_object_id__
+      end
+
+      it "converts each value in the hash" do
+        mongoized[:field].should eq(object_id)
+      end
+    end
+
+    context "when values have object ids" do
+
+      let(:object_id) do
+        Moped::BSON::ObjectId.new
+      end
+
+      let(:hash) do
+        { field: object_id }
+      end
+
+      let(:mongoized) do
+        hash.__mongoize_object_id__
+      end
+
+      it "converts each value in the hash" do
+        mongoized[:field].should eq(object_id)
+      end
+    end
+
+    context "when values have empty strings" do
+
+      let(:object_id) do
+        Moped::BSON::ObjectId.new
+      end
+
+      let(:hash) do
+        { field: "" }
+      end
+
+      let(:mongoized) do
+        hash.__mongoize_object_id__
+      end
+
+      it "converts the empty strings to nil" do
+        mongoized[:field].should be_nil
+      end
+    end
+
+    context "when values have nils" do
+
+      let(:object_id) do
+        Moped::BSON::ObjectId.new
+      end
+
+      let(:hash) do
+        { field: nil }
+      end
+
+      let(:mongoized) do
+        hash.__mongoize_object_id__
+      end
+
+      it "retains the nil values" do
+        mongoized[:field].should be_nil
+      end
+    end
+  end
+
+  describe "#__consolidate__" do
+
+    context "when the hash already contains the key" do
+
+      context "when the $set is first" do
+
+        let(:hash) do
+          { "$set" => { name: "Tool" }, likes: 10, "$inc" => { plays: 1 }}
+        end
+
+        let(:consolidated) do
+          hash.__consolidate__(Band)
+        end
+
+        it "moves the non hash values under the provided key" do
+          consolidated.should eq({
+            "$set" => { name: "Tool", likes: 10 }, "$inc" => { plays: 1 }
+          })
+        end
+      end
+
+      context "when the $set is not first" do
+
+        let(:hash) do
+          { likes: 10, "$inc" => { plays: 1 }, "$set" => { name: "Tool" }}
+        end
+
+        let(:consolidated) do
+          hash.__consolidate__(Band)
+        end
+
+        it "moves the non hash values under the provided key" do
+          consolidated.should eq({
+            "$set" => { likes: 10, name: "Tool" }, "$inc" => { plays: 1 }
+          })
+        end
+      end
+    end
+
+    context "when the hash does not contain the key" do
+
+      let(:hash) do
+        { likes: 10, "$inc" => { plays: 1 }, name: "Tool"}
+      end
+
+      let(:consolidated) do
+        hash.__consolidate__(Band)
+      end
+
+      it "moves the non hash values under the provided key" do
+        consolidated.should eq({
+          "$set" => { likes: 10, name: "Tool" }, "$inc" => { plays: 1 }
+        })
+      end
+    end
+  end
+
+  context "when the hash key is a string" do
+
+    let(:hash) do
+      { "100" => { "name" => "hundred" } }
+    end
+
+    let(:nested) do
+      hash.__nested__("100.name")
+    end
+
+    it "should retrieve a nested value under the provided key" do
+      nested.should eq "hundred"
+    end
+  end
+
+  context "when the hash key is an integer" do
+
+    let(:hash) do
+      { 100 => { "name" => "hundred" } }
+    end
+
+    let(:nested) do
+      hash.__nested__("100.name")
+    end
+
+    it "should retrieve a nested value under the provided key" do
+      nested.should eq("hundred")
+    end
+  end
+
+  describe ".demongoize" do
+
+    let(:hash) do
+      { field: 1 }
+    end
+
+    it "returns the hash" do
+      Hash.demongoize(hash).should eq(hash)
+    end
+  end
+
+  describe ".mongoize" do
+
+    context "when object isn't nil" do
+
+      let(:date) do
+        Date.new(2012, 1, 1)
+      end
+
+      let(:hash) do
+        { date: date }
+      end
+
+      let(:mongoized) do
+        Hash.mongoize(hash)
+      end
+
+      it "mongoizes each element in the hash" do
+        mongoized[:date].should be_a(Time)
+      end
+
+      it "converts the elements properly" do
+        mongoized[:date].should eq(date)
+      end
+    end
+
+    context "when object is nil" do
+      let(:mongoized) do
+        Hash.mongoize(nil)
+      end
+
+      it "returns nil" do
+        mongoized.should be_nil
+      end
+    end
+  end
+
+  describe "#mongoize" do
+
+    let(:date) do
+      Date.new(2012, 1, 1)
+    end
+
+    let(:hash) do
+      { date: date }
+    end
+
+    let(:mongoized) do
+      hash.mongoize
+    end
+
+    it "mongoizes each element in the hash" do
+      mongoized[:date].should be_a(Time)
+    end
+
+    it "converts the elements properly" do
+      mongoized[:date].should eq(date)
+    end
+  end
+
+  describe "#resizable?" do
+
+    it "returns true" do
+      {}.should be_resizable
+    end
+  end
+
+  describe ".resizable?" do
+
+    it "returns true" do
+      Hash.should be_resizable
+    end
+  end
+end