mongoid 3.1.4 → 3.1.5

data/spec/mongoid/extensions/string_spec.rb

@@ -0,0 +1,368 @@
+require "spec_helper"
+
+describe Mongoid::Extensions::String do
+
+  describe "#__evolve_object_id__" do
+
+    context "when the string is blank" do
+
+      it "returns the empty string" do
+        "".__evolve_object_id__.should be_empty
+      end
+    end
+
+    context "when the string is a legal object id" do
+
+      let(:object_id) do
+        Moped::BSON::ObjectId.new
+      end
+
+      it "returns the object id" do
+        object_id.to_s.__evolve_object_id__.should eq(object_id)
+      end
+    end
+
+    context "when the string is not a legal object id" do
+
+      let(:string) do
+        "testing"
+      end
+
+      it "returns the string" do
+        string.__evolve_object_id__.should eq(string)
+      end
+    end
+  end
+
+  describe "#__mongoize_object_id__" do
+
+    context "when the string is blank" do
+
+      it "returns nil" do
+        "".__mongoize_object_id__.should be_nil
+      end
+    end
+
+    context "when the string is a legal object id" do
+
+      let(:object_id) do
+        Moped::BSON::ObjectId.new
+      end
+
+      it "returns the object id" do
+        object_id.to_s.__mongoize_object_id__.should eq(object_id)
+      end
+    end
+
+    context "when the string is not a legal object id" do
+
+      let(:string) do
+        "testing"
+      end
+
+      it "returns the string" do
+        string.__mongoize_object_id__.should eq(string)
+      end
+    end
+  end
+
+  describe "#__mongoize_time__" do
+
+    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 = "Berlin"
+      end
+
+      context "when the string is a valid time" do
+
+        let(:string) do
+          "2010-11-19 00:24:49 +0900"
+        end
+
+        let(:time) do
+          string.__mongoize_time__
+        end
+
+        it "converts to a time" do
+          time.should eq(Time.configured.parse(string))
+        end
+
+        it "converts to the as time zone" do
+          time.zone.should eq("JST")
+        end
+      end
+
+      context "when the string is an invalid time" do
+
+        let(:string) do
+          "shitty string"
+        end
+
+        it "raises an error" do
+          expect {
+            string.__mongoize_time__
+          }.to raise_error(ArgumentError)
+        end
+      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
+
+      context "when the string is a valid time" do
+
+        let(:string) do
+          "2010-11-19 00:24:49 +0900"
+        end
+
+        let(:time) do
+          string.__mongoize_time__
+        end
+
+        it "converts to a time" do
+          time.should eq(Time.parse(string))
+        end
+      end
+
+      context "when the string is an invalid time" do
+
+        let(:string) do
+          "shitty string"
+        end
+
+        it "raises an error" do
+          expect {
+            string.__mongoize_time__
+          }.to raise_error(ArgumentError)
+        end
+      end
+    end
+  end
+
+  describe "#collectionize" do
+
+    context "when class is namepaced" do
+
+      module Medical
+        class Patient
+          include Mongoid::Document
+        end
+      end
+
+      it "returns an underscored tableized name" do
+        Medical::Patient.name.collectionize.should eq("medical_patients")
+      end
+    end
+
+    context "when class is not namespaced" do
+
+      it "returns an underscored tableized name" do
+        MixedDrink.name.collectionize.should eq("mixed_drinks")
+      end
+    end
+  end
+
+  describe ".demongoize" do
+
+    context "when the object is not a string" do
+
+      it "returns the string" do
+        String.demongoize(:test).should eq("test")
+      end
+    end
+
+    context "when the object is nil" do
+
+      it "returns nil" do
+        String.demongoize(nil).should be_nil
+      end
+    end
+  end
+
+  describe "#mongoid_id?" do
+
+    context "when the string is id" do
+
+      it "returns true" do
+        "id".should be_mongoid_id
+      end
+    end
+
+    context "when the string is _id" do
+
+      it "returns true" do
+        "_id".should be_mongoid_id
+      end
+    end
+
+    context "when the string contains id" do
+
+      it "returns false" do
+        "identity".should_not be_mongoid_id
+      end
+    end
+
+    context "when the string contains _id" do
+
+      it "returns false" do
+        "something_id".should_not be_mongoid_id
+      end
+    end
+  end
+
+  describe ".mongoize" do
+
+    context "when the object is not a string" do
+
+      it "returns the string" do
+        String.mongoize(:test).should eq("test")
+      end
+    end
+
+    context "when the object is nil" do
+
+      it "returns nil" do
+        String.mongoize(nil).should be_nil
+      end
+    end
+  end
+
+  describe "#mongoize" do
+
+    it "returns self" do
+      "test".mongoize.should eq("test")
+    end
+  end
+
+  describe "#reader" do
+
+    context "when string is a reader" do
+
+      it "returns self" do
+        "attribute".reader.should eq("attribute")
+      end
+    end
+
+    context "when string is a writer" do
+
+      it "returns the reader" do
+        "attribute=".reader.should eq("attribute")
+      end
+    end
+
+    context "when the string is before_type_cast" do
+
+      it "returns the reader" do
+        "attribute_before_type_cast".reader.should eq("attribute")
+      end
+    end
+  end
+
+  describe "#numeric?" do
+
+    context "when the string is an integer" do
+
+      it "returns true" do
+        "1234".should be_numeric
+      end
+    end
+
+    context "when string is a float" do
+
+      it "returns true" do
+        "1234.123".should be_numeric
+      end
+    end
+
+    context "when the string is has exponents" do
+
+      it "returns true" do
+        "1234.123123E4".should be_numeric
+      end
+    end
+
+    context "when the string is non numeric" do
+
+      it "returns false" do
+        "blah".should_not be_numeric
+      end
+    end
+  end
+
+  describe "#singularize" do
+
+    context "when string is address" do
+
+      it "returns address" do
+        "address".singularize.should eq("address")
+      end
+    end
+
+    context "when string is address_profiles" do
+
+      it "returns address_profile" do
+        "address_profiles".singularize.should eq("address_profile")
+      end
+    end
+  end
+
+  describe "#to_a" do
+
+    let(:value) do
+      "Disintegration is the best album ever!"
+    end
+
+    it "returns an array with the string in it" do
+      value.to_a.should eq([ value ])
+    end
+  end
+
+  describe "#writer?" do
+
+    context "when string is a reader" do
+
+      it "returns false" do
+        "attribute".writer?.should be_false
+      end
+    end
+
+    context "when string is a writer" do
+
+      it "returns true" do
+        "attribute=".writer?.should be_true
+      end
+    end
+  end
+
+  describe "#before_type_cast?" do
+
+    context "when string is a reader" do
+
+      it "returns false" do
+        "attribute".before_type_cast?.should be_false
+      end
+    end
+
+    context "when string is before_type_cast" do
+
+      it "returns true" do
+        "attribute_before_type_cast".before_type_cast?.should be_true
+      end
+    end
+  end
+
+end

data/spec/mongoid/extensions/symbol_spec.rb

@@ -0,0 +1,76 @@
+require "spec_helper"
+
+describe Mongoid::Extensions::Symbol do
+
+  describe ".demongoize" do
+
+    context "when the object is not a symbol" do
+
+      it "returns the symbol" do
+        Symbol.demongoize("test").should eq(:test)
+      end
+    end
+
+    context "when the object is nil" do
+
+      it "returns nil" do
+        Symbol.demongoize(nil).should be_nil
+      end
+    end
+  end
+
+  describe "#mongoid_id?" do
+
+    context "when the string is id" do
+
+      it "returns true" do
+        :id.should be_mongoid_id
+      end
+    end
+
+    context "when the string is _id" do
+
+      it "returns true" do
+        :_id.should be_mongoid_id
+      end
+    end
+
+    context "when the string contains id" do
+
+      it "returns false" do
+        :identity.should_not be_mongoid_id
+      end
+    end
+
+    context "when the string contains _id" do
+
+      it "returns false" do
+        :something_id.should_not be_mongoid_id
+      end
+    end
+  end
+
+  describe ".mongoize" do
+
+    context "when the object is not a symbol" do
+
+      it "returns the symbol" do
+        Symbol.mongoize("test").should eq(:test)
+      end
+    end
+
+    context "when the object is nil" do
+
+      it "returns nil" do
+        Symbol.mongoize(nil).should be_nil
+      end
+    end
+  end
+
+  describe "#mongoize" do
+
+    it "returns self" do
+      :test.mongoize.should eq(:test)
+    end
+  end
+end

data/spec/mongoid/extensions/time_spec.rb

@@ -0,0 +1,467 @@
+require "spec_helper"
+
+describe Mongoid::Extensions::Time do
+
+  describe ".demongoize" do
+
+    after(:all) do
+      Mongoid.use_utc = false
+      Mongoid.use_activesupport_time_zone = true
+    end
+
+    let!(:time) do
+      Time.local(2010, 11, 19)
+    end
+
+    context "when the time zone is not defined" do
+
+      before do
+        Mongoid.use_utc = false
+      end
+
+      context "when the local time is not observing daylight saving" do
+
+        let(:time) do
+          Time.utc(2010, 11, 19)
+        end
+
+        it "returns the local time" do
+          Time.demongoize(time).utc_offset.should eq(
+            Time.local(2010, 11, 19).utc_offset
+          )
+        end
+      end
+
+      context "when the local time is observing daylight saving" do
+
+        let(:time) do
+          Time.utc(2010, 9, 19)
+        end
+
+        it "returns the local time" do
+          Time.demongoize(time).should eq(time.getlocal)
+        end
+      end
+
+      context "when we have a time close to midnight" do
+
+        let(:time) do
+          Time.local(2010, 11, 19, 0, 30).utc
+        end
+
+        it "changes it back to the equivalent local time" do
+          Time.demongoize(time).should eq(time)
+        end
+      end
+
+      context "when using the ActiveSupport time zone" do
+
+        before do
+          Mongoid.use_activesupport_time_zone = true
+          Time.zone = "Stockholm"
+        end
+
+        after do
+          Time.zone = nil
+          Mongoid.use_activesupport_time_zone = false
+        end
+
+        it "returns an ActiveSupport::TimeWithZone" do
+          Time.demongoize(time).class.should eq(ActiveSupport::TimeWithZone)
+        end
+
+        context "when the local time is not observing daylight saving" do
+
+          let(:new_time) do
+            Time.utc(2010, 11, 19, 12)
+          end
+
+          it "returns the local time" do
+            Time.demongoize(new_time).should eq(
+              Time.zone.local(2010, 11, 19, 13)
+            )
+          end
+        end
+
+        context "when the local time is observing daylight saving" do
+
+          let(:new_time) do
+            Time.utc(2010, 9, 19, 12)
+          end
+
+          it "returns the local time" do
+            Time.demongoize(new_time).should eq(
+              Time.zone.local(2010, 9, 19, 14)
+            )
+          end
+        end
+
+        context "when we have a time close to midnight" do
+
+          let(:new_time) do
+            Time.utc(2010, 11, 19, 0, 30)
+          end
+
+          it "change it back to the equivalent local time" do
+            Time.demongoize(new_time).should eq(
+              Time.zone.local(2010, 11, 19, 1, 30)
+            )
+          end
+        end
+      end
+    end
+
+    context "when the time zone is defined as UTC" do
+
+      before do
+        Mongoid.use_utc = true
+      end
+
+      after do
+        Mongoid.use_utc = false
+      end
+
+      it "returns utc" do
+        Time.demongoize(time.dup.utc).utc_offset.should eq(0)
+      end
+
+      context "when using the ActiveSupport time zone" do
+
+        let(:time) do
+          Time.utc(2010, 11, 19, 0, 30)
+        end
+
+        before do
+          Mongoid.use_activesupport_time_zone = true
+          Time.zone = "Stockholm"
+        end
+
+        after do
+          Time.zone = nil
+          Mongoid.use_activesupport_time_zone = false
+        end
+
+        it "returns utc" do
+          Time.demongoize(time).should eq(
+            ActiveSupport::TimeZone['UTC'].local(2010, 11, 19, 0, 30)
+          )
+        end
+
+        it "returns an ActiveSupport::TimeWithZone" do
+          Time.demongoize(time).class.should eq(
+            ActiveSupport::TimeWithZone
+          )
+        end
+      end
+    end
+
+    context "when time is nil" do
+
+      it "returns nil" do
+        Time.demongoize(nil).should be_nil
+      end
+    end
+  end
+
+  describe ".mongoize" do
+
+    let!(:time) do
+      Time.local(2010, 11, 19)
+    end
+
+    context "when given nil" do
+
+      it "returns nil" do
+        Time.mongoize(nil).should be_nil
+      end
+    end
+
+    context "when string is empty" do
+
+      it "returns nil" do
+        Time.mongoize("").should be_nil
+      end
+    end
+
+    context "when given a string" do
+
+      context "when the string is a valid time" do
+
+        it "converts to a utc time" do
+          Time.mongoize(time.to_s).utc_offset.should eq(0)
+        end
+
+        it "serializes with time parsing" do
+          Time.mongoize(time.to_s).should eq(Time.parse(time.to_s).utc)
+        end
+
+        it "returns a local date from the string" do
+          Time.mongoize(time.to_s).should eq(
+            Time.local(time.year, time.month, time.day, time.hour, time.min, time.sec)
+          )
+        end
+      end
+
+      context "when the string is an invalid time" do
+
+        let(:epoch) do
+          Time.utc(1970, 1, 1, 0, 0, 0, 0)
+        end
+
+        it "converts the time to epoch" do
+          Time.mongoize("time").should eq(epoch)
+        end
+      end
+
+      context "when using the ActiveSupport time zone" do
+
+        before do
+          Mongoid.use_activesupport_time_zone = true
+          # if this is actually your time zone, the following tests are useless
+          Time.zone = "Stockholm"
+        end
+
+        after do
+          Time.zone = nil
+          Mongoid.use_activesupport_time_zone = false
+        end
+
+        context "when the local time is not observing daylight saving" do
+
+          it "returns the local time" do
+            Time.mongoize('2010-11-19 5:00:00').should eq(
+              Time.utc(2010, 11, 19, 4)
+            )
+          end
+        end
+
+        context "when the local time is observing daylight saving" do
+
+          it "returns the local time" do
+            Time.mongoize('2010-9-19 5:00:00').should eq(
+              Time.utc(2010, 9, 19, 3)
+            )
+          end
+        end
+      end
+    end
+
+    context "when given a DateTime" do
+
+      let!(:time) do
+        DateTime.now
+      end
+
+      let!(:eom_time) do
+        DateTime.parse("2012-11-30T23:59:59.999999999-05:00")
+      end
+
+      let!(:eom_time_mongoized) do
+        eom_time.mongoize
+      end
+
+      it "doesn't strip milli- or microseconds" do
+        Time.mongoize(time).to_f.round(3).should eq(time.to_f.round(3))
+      end
+
+      it "doesn't round up the hour at end of month" do
+        eom_time_mongoized.hour.should eq(eom_time.utc.hour)
+      end
+
+      it "doesn't round up the minute" do
+        eom_time_mongoized.min.should eq(eom_time.utc.min)
+      end
+
+      it "doesn't round up the seconds" do
+        eom_time_mongoized.sec.should eq(eom_time.utc.sec)
+      end
+
+      it "does not alter seconds" do
+        (eom_time_mongoized.usec).should eq(999999)
+      end
+
+      it "does not alter seconds with fractions" do
+        DateTime.mongoize(11.11).to_f.should eq(11.11)
+      end
+
+      context "when using the ActiveSupport time zone" do
+
+        let(:datetime) do
+          DateTime.new(2010, 11, 19)
+        end
+
+        before do
+          Mongoid.use_activesupport_time_zone = true
+          # if this is actually your time zone, the following tests are useless
+          Time.zone = "Stockholm"
+        end
+
+        after do
+          Time.zone = nil
+          Mongoid.use_activesupport_time_zone = false
+        end
+
+        it "assumes the given time is local" do
+          Time.mongoize(datetime).should eq(
+            Time.utc(2010, 11, 19)
+          )
+        end
+
+        it "doesn't round up the hour" do
+          eom_time_mongoized.hour.should eq(eom_time.utc.hour)
+        end
+
+        it "doesn't round up the minutes" do
+          eom_time_mongoized.min.should eq(eom_time.utc.min)
+        end
+
+        it "doesn't round up the seconds" do
+          eom_time_mongoized.sec.should eq(eom_time.utc.sec)
+        end
+
+        it "does not alter the seconds" do
+          (eom_time_mongoized.usec).should eq(999999)
+        end
+      end
+    end
+
+    context "when given a Time" do
+
+      it "converts to a utc time" do
+        Time.mongoize(time).utc_offset.should eq(0)
+      end
+
+      it "returns utc times unchanged" do
+        Time.mongoize(time.utc).should eq(time.utc)
+      end
+
+      it "returns the time as utc" do
+        Time.mongoize(time).should eq(time.utc)
+      end
+
+      it "doesn't strip milli- or microseconds" do
+        Time.mongoize(time).to_f.should eq(time.to_f)
+      end
+
+      it "does not alter seconds with fractions" do
+        Time.mongoize(102.63).to_f.should eq(102.63)
+      end
+    end
+
+    context "when given an ActiveSupport::TimeWithZone" do
+
+      before do
+        1.hour.ago
+      end
+
+      it "converts it to utc" do
+        Time.mongoize(time.in_time_zone("Alaska")).should eq(
+          Time.at(time.to_i).utc
+        )
+      end
+    end
+
+    context "when given a Date" do
+
+      let(:date) do
+        Date.today
+      end
+
+      it "converts to a utc time" do
+        Time.mongoize(date).should eq(Time.local(date.year, date.month, date.day))
+      end
+
+      it "has a zero utc offset" do
+        Time.mongoize(date).utc_offset.should eq(0)
+      end
+
+      context "when using the ActiveSupport time zone" do
+
+        let(:date) do
+          Date.new(2010, 11, 19)
+        end
+
+        before do
+          Mongoid.use_activesupport_time_zone = true
+          # if this is actually your time zone, the following tests are useless
+          Time.zone = "Stockholm"
+        end
+
+        after do
+          Time.zone = nil
+          Mongoid.use_activesupport_time_zone = false
+        end
+
+        it "assumes the given time is local" do
+          Time.mongoize(date).should eq(Time.utc(2010, 11, 18, 23))
+        end
+      end
+    end
+
+    context "when given an array" do
+
+      let(:array) do
+        [ 2010, 11, 19, 00, 24, 49 ]
+      end
+
+      it "returns a time" do
+        Time.mongoize(array).should eq(Time.local(*array))
+      end
+
+      context "when using the ActiveSupport time zone" do
+
+        before do
+          Mongoid.use_activesupport_time_zone = true
+          # if this is actually your time zone, the following tests are useless
+          Time.zone = "Stockholm"
+        end
+
+        after do
+          Time.zone = nil
+          Mongoid.use_activesupport_time_zone = false
+        end
+
+        it "assumes the given time is local" do
+          Time.mongoize(array).should eq(
+            Time.utc(2010, 11, 18, 23, 24, 49)
+          )
+        end
+      end
+    end
+  end
+
+  describe "#mongoize" do
+
+    let!(:time) do
+      Time.local(2010, 11, 19)
+    end
+
+    let!(:eom_time) do
+      Time.local(2012, 11, 30, 23, 59, 59, 999999.999)
+    end
+
+    let!(:eom_time_mongoized) do
+      eom_time.mongoize
+    end
+
+    it "converts to a utc time" do
+      time.mongoize.utc_offset.should eq(0)
+    end
+
+    it "returns the time as utc" do
+      time.mongoize.should eq(time.utc)
+    end
+
+    it "doesn't strip milli- or microseconds" do
+      time.mongoize.to_f.should eq(time.to_f)
+    end
+
+    it "doesn't round up at end of month" do
+      eom_time_mongoized.hour.should eq(eom_time.utc.hour)
+      eom_time_mongoized.min.should eq(eom_time.utc.min)
+      eom_time_mongoized.sec.should eq(eom_time.utc.sec)
+      eom_time_mongoized.usec.should eq(eom_time.utc.usec)
+      eom_time_mongoized.subsec.to_f.round(3).should eq(eom_time.utc.subsec.to_f.round(3))
+    end
+  end
+end