mongoid 3.1.4 → 3.1.5

data/spec/mongoid/extensions/time_with_zone_spec.rb

@@ -0,0 +1,405 @@
+require "spec_helper"
+
+describe Mongoid::Extensions::TimeWithZone 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
+          ActiveSupport::TimeWithZone.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
+          ActiveSupport::TimeWithZone.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
+          ActiveSupport::TimeWithZone.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
+          ActiveSupport::TimeWithZone.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
+            ActiveSupport::TimeWithZone.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
+            ActiveSupport::TimeWithZone.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
+            ActiveSupport::TimeWithZone.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
+        ActiveSupport::TimeWithZone.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
+          ActiveSupport::TimeWithZone.demongoize(time).should eq(
+            ActiveSupport::TimeZone['UTC'].local(2010, 11, 19, 0, 30)
+          )
+        end
+
+        it "returns an ActiveSupport::TimeWithZone" do
+          ActiveSupport::TimeWithZone.demongoize(time).class.should eq(
+            ActiveSupport::TimeWithZone
+          )
+        end
+      end
+    end
+
+    context "when time is nil" do
+
+      it "returns nil" do
+        ActiveSupport::TimeWithZone.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
+        ActiveSupport::TimeWithZone.mongoize(nil).should be_nil
+      end
+    end
+
+    context "when string is empty" do
+
+      it "returns nil" do
+        ActiveSupport::TimeWithZone.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
+          ActiveSupport::TimeWithZone.mongoize(time.to_s).utc_offset.should eq(0)
+        end
+
+        it "serializes with time parsing" do
+          ActiveSupport::TimeWithZone.mongoize(time.to_s).should eq(Time.parse(time.to_s).utc)
+        end
+
+        it "returns a local date from the string" do
+          ActiveSupport::TimeWithZone.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)
+        end
+
+        it "returns epoch" do
+          ActiveSupport::TimeWithZone.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
+            ActiveSupport::TimeWithZone.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
+            ActiveSupport::TimeWithZone.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
+        Time.now
+      end
+
+      it "doesn't strip milli- or microseconds" do
+        ActiveSupport::TimeWithZone.mongoize(time).to_f.round(4).should eq(
+          time.to_f.round(4)
+        )
+      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
+          ActiveSupport::TimeWithZone.mongoize(datetime).should eq(
+            Time.utc(2010, 11, 19)
+          )
+        end
+      end
+    end
+
+    context "when given a Time" do
+
+      it "converts to a utc time" do
+        ActiveSupport::TimeWithZone.mongoize(time).utc_offset.should eq(0)
+      end
+
+      it "returns utc times unchanged" do
+        ActiveSupport::TimeWithZone.mongoize(time.utc).should eq(time.utc)
+      end
+
+      it "returns the time as utc" do
+        ActiveSupport::TimeWithZone.mongoize(time).should eq(time.utc)
+      end
+
+      it "doesn't strip milli- or microseconds" do
+        ActiveSupport::TimeWithZone.mongoize(time).to_f.should eq(time.to_f)
+      end
+    end
+
+    context "when given an ActiveSupport::TimeWithZone" do
+
+      before do
+        1.hour.ago
+      end
+
+      it "converts it to utc" do
+        ActiveSupport::TimeWithZone.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
+        ActiveSupport::TimeWithZone.mongoize(date).should eq(Time.local(date.year, date.month, date.day))
+      end
+
+      it "has a zero utc offset" do
+        ActiveSupport::TimeWithZone.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
+          ActiveSupport::TimeWithZone.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
+        ActiveSupport::TimeWithZone.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
+          ActiveSupport::TimeWithZone.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
+
+    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
+  end
+end

data/spec/mongoid/extensions/true_class_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+
+describe Mongoid::Extensions::TrueClass do
+
+  describe "#__sortable__" do
+
+    it "returns 1" do
+      true.__sortable__.should eq(1)
+    end
+  end
+
+  describe "#is_a?" do
+
+    context "when provided a Boolean" do
+
+      it "returns true" do
+        true.is_a?(Boolean).should be_true
+      end
+    end
+
+    context "when provided a FalseClass" do
+
+      it "returns false" do
+        true.is_a?(FalseClass).should be_false
+      end
+    end
+
+    context "when provided a TrueClass" do
+
+      it "returns true" do
+        true.is_a?(TrueClass).should be_true
+      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/factory_spec.rb

@@ -0,0 +1,185 @@
+require "spec_helper"
+
+describe Mongoid::Factory do
+
+  describe ".build" do
+
+    context "when the type attribute is present" do
+
+      let(:attributes) do
+        { "_type" => "Person", "title" => "Sir" }
+      end
+
+      context "when the type is a class" do
+
+        let(:person) do
+          described_class.build(Person, attributes)
+        end
+
+        it "instantiates based on the type" do
+          person.title.should eq("Sir")
+        end
+      end
+
+      context "when the type is a not a subclass" do
+
+        let(:person) do
+          described_class.build(Person, { "_type" => "Canvas" })
+        end
+
+        it "instantiates the provided class" do
+          person.class.should eq(Person)
+        end
+      end
+
+      context "when the type is a subclass of the provided" do
+
+        let(:person) do
+          described_class.build(Person, { "_type" => "Doctor" })
+        end
+
+        it "instantiates the subclass" do
+          person.class.should eq(Doctor)
+        end
+      end
+
+      context "when type is an empty string" do
+
+        let(:attributes) do
+          { "title" => "Sir", "_type" => "" }
+        end
+
+        let(:person) do
+          described_class.build(Person, attributes)
+        end
+
+        it "instantiates based on the type" do
+          person.title.should eq("Sir")
+        end
+      end
+
+      context "when type is the lower case class name" do
+
+        let(:attributes) do
+          { "title" => "Sir", "_type" => "person" }
+        end
+
+        let(:person) do
+          described_class.build(Person, attributes)
+        end
+
+        it "instantiates based on the type" do
+          person.title.should eq("Sir")
+        end
+      end
+    end
+
+    context "when type is not preset" do
+
+      let(:attributes) do
+        { "title" => "Sir" }
+      end
+
+      let(:person) do
+        described_class.build(Person, attributes)
+      end
+
+      it "instantiates based on the provided class" do
+        person.title.should eq("Sir")
+      end
+    end
+  end
+
+  describe ".from_db" do
+
+    context "when the attributes are nil" do
+
+      let(:document) do
+        described_class.from_db(Address, nil)
+      end
+
+      it "generates based on the provided class" do
+        document.should be_a(Address)
+      end
+
+      it "sets the attributes to empty" do
+        document.attributes.should be_empty
+      end
+    end
+
+    context "when a type is in the attributes" do
+
+      context "when the type is a class" do
+
+        let(:attributes) do
+          { "_type" => "Person", "title" => "Sir" }
+        end
+
+        let(:document) do
+          described_class.from_db(Address, attributes)
+        end
+
+        it "generates based on the type" do
+          document.should be_a(Person)
+        end
+
+        it "sets the attributes" do
+          document.title.should eq("Sir")
+        end
+      end
+
+      context "when the type is empty" do
+
+        let(:attributes) do
+          { "_type" => "", "title" => "Sir" }
+        end
+
+        let(:document) do
+          described_class.from_db(Person, attributes)
+        end
+
+        it "generates based on the provided class" do
+          document.should be_a(Person)
+        end
+
+        it "sets the attributes" do
+          document.title.should eq("Sir")
+        end
+      end
+
+      context "when type is the lower case class name" do
+
+        let(:attributes) do
+          { "title" => "Sir", "_type" => "person" }
+        end
+
+        let(:person) do
+          described_class.from_db(Person, attributes)
+        end
+
+        it "instantiates based on the type" do
+          person.title.should eq("Sir")
+        end
+      end
+    end
+
+    context "when a type is not in the attributes" do
+
+      let(:attributes) do
+        { "title" => "Sir" }
+      end
+
+      let(:document) do
+        described_class.from_db(Person, attributes)
+      end
+
+      it "generates based on the provided class" do
+        document.should be_a(Person)
+      end
+
+      it "sets the attributes" do
+        document.title.should eq("Sir")
+      end
+    end
+  end
+end