mongoid_heroku_stable 4.0.0

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
+
+      pending "does not drop the precision" do
+        expect(mongoized.to_f.to_s).to 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
+        expect(mongoized).to 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
+        expect(mongoized).to 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
+      expect(date_time).to be_kind_of(DateTime)
+    end
+
+    it "does not change the time" do
+      expect(DateTime.demongoize(time)).to 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
+          expect(user.last_login).to 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
+        expect(DateTime.mongoize("time")).to 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
+        expect(date_time.mongoize).to 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
+      expect(false.__sortable__).to eq(0)
+    end
+  end
+
+  describe "#is_a?" do
+
+    context "when provided a Boolean" do
+
+      it "returns true" do
+        expect(false.is_a?(Boolean)).to be_true
+      end
+    end
+
+    context "when provided a FalseClass" do
+
+      it "returns true" do
+        expect(false.is_a?(FalseClass)).to be_true
+      end
+    end
+
+    context "when provided a TrueClass" do
+
+      it "returns false" do
+        expect(false.is_a?(TrueClass)).to be_false
+      end
+    end
+
+    context "when provided an invalid class" do
+
+      it "returns false" do
+        expect(false.is_a?(String)).to 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
+      expect(mongoized).to eq(Time.at(float))
+    end
+  end
+
+  describe ".demongoize" do
+
+    context "when the the value is a float" do
+
+      it "returns a float" do
+        expect(Float.demongoize(number)).to eq(number)
+      end
+    end
+
+    context "when the value is nil" do
+
+      it "returns nil" do
+        expect(Float.demongoize(nil)).to 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
+            expect(Float.mongoize(3)).to eq(3)
+          end
+
+          it "returns the number as type float" do
+            expect(Float.mongoize(3)).to be_a(Float)
+          end
+        end
+
+        context "when the value is large" do
+
+          it "returns the float" do
+            expect(Float.mongoize(1024**2).to_s).to eq("1048576.0")
+          end
+        end
+      end
+
+      context "when the value is a decimal" do
+
+        it "casts to float" do
+          expect(Float.mongoize(2.5)).to eq(2.5)
+        end
+      end
+
+      context "when the value is floating point zero" do
+
+        it "returns the float zero" do
+          expect(Float.mongoize(0.00000)).to eq(0)
+        end
+      end
+
+      context "when the value is a floating point float" do
+
+        it "returns the float number" do
+          expect(Float.mongoize(4.00000)).to eq(4)
+        end
+      end
+
+      context "when the value has leading zeros" do
+
+        it "returns the stripped float" do
+          expect(Float.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(Float.mongoize("foo")).to eq(0.0)
+        end
+      end
+
+      context "when the string is numerical" do
+
+        it "returns the float value for the string" do
+          expect(Float.mongoize("3")).to eq(3)
+        end
+      end
+
+      context "when the string is empty" do
+
+        it "returns nil" do
+          expect(Float.mongoize("")).to be_nil
+        end
+      end
+
+      context "when the string is nil" do
+
+        it "returns nil" do
+          expect(Float.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/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
+        expect(evolved[:field]).to 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
+        expect(evolved[:field]).to 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
+        expect(evolved[:field]).to 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
+        expect(evolved[:field]).to 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
+        expect(mongoized[:field]).to 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
+        expect(mongoized[:field]).to 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
+        expect(mongoized[:field]).to 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
+        expect(mongoized[:field]).to 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
+          expect(consolidated).to 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
+          expect(consolidated).to 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
+        expect(consolidated).to 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
+      expect(nested).to 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
+      expect(nested).to eq("hundred")
+    end
+  end
+
+  describe ".demongoize" do
+
+    let(:hash) do
+      { field: 1 }
+    end
+
+    it "returns the hash" do
+      expect(Hash.demongoize(hash)).to 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
+        expect(mongoized[:date]).to be_a(Time)
+      end
+
+      it "converts the elements properly" do
+        expect(mongoized[:date]).to eq(Time.utc(2012, 1, 1, 0, 0, 0))
+      end
+    end
+
+    context "when object is nil" do
+      let(:mongoized) do
+        Hash.mongoize(nil)
+      end
+
+      it "returns nil" do
+        expect(mongoized).to 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
+      expect(mongoized[:date]).to be_a(Time)
+    end
+
+    it "converts the elements properly" do
+      expect(mongoized[:date]).to eq(Time.utc(2012, 1, 1, 0, 0, 0))
+    end
+  end
+
+  describe "#resizable?" do
+
+    it "returns true" do
+      expect({}).to be_resizable
+    end
+  end
+
+  describe ".resizable?" do
+
+    it "returns true" do
+      expect(Hash).to be_resizable
+    end
+  end
+end