motion-support 0.1.0 → 0.2.0

data/spec/motion-support/core_ext/string/inflection_spec.rb

@@ -0,0 +1,142 @@
+describe "String" do
+  describe "Inflections" do
+    describe "singularize" do
+      InflectorTestCases::SingularToPlural.each do |singular, plural|
+        it "should pluralize singular #{singular}" do
+          singular.pluralize.should == plural
+        end
+      end
+      
+      it "should pluralize plural" do
+        "plurals".pluralize.should == "plurals"
+      end
+      
+      it "should pluralize with number" do
+        "blargle".pluralize(0).should == "blargles"
+        "blargle".pluralize(1).should == "blargle"
+        "blargle".pluralize(2).should == "blargles"
+      end
+    end
+    
+    describe "singularize" do
+      InflectorTestCases::SingularToPlural.each do |singular, plural|
+        it "should singularize plural #{plural}" do
+          plural.singularize.should == singular
+        end
+      end
+    end
+    
+    describe "titleize" do
+      InflectorTestCases::MixtureToTitleCase.each do |before, titleized|
+        it "should titleize #{before}" do
+          before.titleize.should == titleized
+        end
+      end
+    end
+    
+    describe "camelize" do
+      InflectorTestCases::CamelToUnderscore.each do |camel, underscore|
+        it "should camelize #{underscore}" do
+          underscore.camelize.should == camel
+        end
+      end
+
+      it "should lower-camelize" do
+        'Capital'.camelize(:lower).should == 'capital'
+      end
+    end
+    
+    describe "dasherize" do
+      InflectorTestCases::UnderscoresToDashes.each do |underscored, dasherized|
+        it "should dasherize #{underscored}" do
+          underscored.dasherize.should == dasherized
+        end
+      end
+    end
+    
+    describe "underscore" do
+      InflectorTestCases::CamelToUnderscore.each do |camel, underscore|
+        it "should underscore #{camel}" do
+          camel.underscore.should == underscore
+        end
+      end
+      
+      it "should underscore acronyms" do
+        "HTMLTidy".underscore.should == "html_tidy"
+        "HTMLTidyGenerator".underscore.should == "html_tidy_generator"
+      end
+
+      InflectorTestCases::UnderscoreToLowerCamel.each do |underscored, lower_camel|
+        it "should lower-camelize #{underscored}" do
+          underscored.camelize(:lower).should == lower_camel
+        end
+      end
+    end
+    
+    it "should demodulize" do
+      "MyApplication::Billing::Account".demodulize.should == "Account"
+    end
+
+    it "should deconstantize" do
+      "MyApplication::Billing::Account".deconstantize.should == "MyApplication::Billing"
+    end
+    
+    describe "foreign_key" do
+      InflectorTestCases::ClassNameToForeignKeyWithUnderscore.each do |klass, foreign_key|
+        it "should build foreign key from #{klass}" do
+          klass.foreign_key.should == foreign_key
+        end
+      end
+
+      InflectorTestCases::ClassNameToForeignKeyWithoutUnderscore.each do |klass, foreign_key|
+        it "should build foreign key from #{klass} without underscore" do
+          klass.foreign_key(false).should == foreign_key
+        end
+      end
+    end
+
+    describe "tableize" do
+      InflectorTestCases::ClassNameToTableName.each do |class_name, table_name|
+        it "should tableize #{class_name}" do
+          class_name.tableize.should == table_name
+        end
+      end
+    end
+
+    describe "classify" do
+      InflectorTestCases::ClassNameToTableName.each do |class_name, table_name|
+        it "should classify #{table_name}" do
+          table_name.classify.should == class_name
+        end
+      end
+    end
+
+    describe "humanize" do
+      InflectorTestCases::UnderscoreToHuman.each do |underscore, human|
+        it "should humanize #{underscore}" do
+          underscore.humanize.should == human
+        end
+      end
+    end
+    
+    describe "constantize" do
+      extend ConstantizeTestCases
+    
+      it "should constantize" do
+        run_constantize_tests_on do |string|
+          string.constantize
+        end
+      end
+    end
+  
+    describe "safe_constantize" do
+      extend ConstantizeTestCases
+    
+      it "should safe_constantize" do
+        run_safe_constantize_tests_on do |string|
+          string.safe_constantize
+        end
+      end
+    end
+  end
+end

data/spec/motion-support/core_ext/string/starts_end_with_spec.rb

@@ -0,0 +1,14 @@
+describe "String" do
+  describe "starts_with?/ends_with?" do
+    it "should have starts/ends_with? alias" do
+      s = "hello"
+      s.starts_with?('h').should.be.true
+      s.starts_with?('hel').should.be.true
+      s.starts_with?('el').should.be.false
+
+      s.ends_with?('o').should.be.true
+      s.ends_with?('lo').should.be.true
+      s.ends_with?('el').should.be.false
+    end
+  end
+end

data/spec/motion-support/core_ext/string/strip_spec.rb

@@ -0,0 +1,34 @@
+describe "String" do
+  describe "strip_heredoc" do
+    it "should strip heredoc on an empty string" do
+      ''.strip_heredoc.should == ''
+    end
+
+    it "should strip heredoc on a string with no lines" do
+      'x'.strip_heredoc.should == 'x'
+      '    x'.strip_heredoc.should == 'x'
+    end
+
+    it "should strip heredoc on a heredoc with no margin" do
+      "foo\nbar".strip_heredoc.should == "foo\nbar"
+      "foo\n  bar".strip_heredoc.should == "foo\n  bar"
+    end
+
+    it "should strip heredoc on a regular indented heredoc" do
+      <<-EOS.strip_heredoc.should == "foo\n  bar\nbaz\n"
+        foo
+          bar
+        baz
+      EOS
+    end
+
+    it "should strip heredoc on a regular indented heredoc with blank lines" do
+      <<-EOS.strip_heredoc.should == "foo\n  bar\n\nbaz\n"
+        foo
+          bar
+
+        baz
+      EOS
+    end
+  end
+end

data/spec/motion-support/core_ext/string_spec.rb

@@ -0,0 +1,88 @@
+describe "string" do
+  describe "constantize" do
+    module Ace
+      module Base
+        class Case
+          class Dice
+          end
+        end
+        class Fase < Case
+        end
+      end
+      class Gas
+        include Base
+      end
+    end
+
+    class Object
+      module AddtlGlobalConstants
+        class Case
+          class Dice
+          end
+        end
+      end
+      include AddtlGlobalConstants
+    end
+    
+    it "should lookup nested constant" do
+      "Ace::Base::Case".constantize.should == Ace::Base::Case
+    end
+    
+    it "should lookup nested absolute constant" do
+      "::Ace::Base::Case".constantize.should == Ace::Base::Case
+    end
+    
+    it "should lookup nested inherited constant" do
+      "Ace::Base::Fase::Dice".constantize.should == Ace::Base::Fase::Dice
+    end
+    
+    it "should lookup nested included constant" do
+      "Ace::Gas::Case".constantize.should == Ace::Gas::Case
+    end
+    
+    it "should lookup nested constant included into Object" do
+      "Case::Dice".constantize.should == Case::Dice
+    end
+    
+    it "should lookup nested absolute constant included into Object" do
+      "Object::Case::Dice".constantize.should == Case::Dice
+    end
+    
+    it "should lookup constant" do
+      "String".constantize.should == String
+    end
+    
+    it "should lookup absolute constant" do
+      "::Ace".constantize.should == Ace
+    end
+    
+    it "should return Object for empty string" do
+      "".constantize.should == Object
+    end
+    
+    it "should return Object for double colon" do
+      "::".constantize.should == Object
+    end
+    
+    it "should raise NameError for unknown constant" do
+      lambda { "UnknownClass".constantize }.should.raise NameError
+    end
+    
+    it "should raise NameError for unknown nested constant" do
+      lambda { "UnknownClass::Ace".constantize }.should.raise NameError
+      lambda { "UnknownClass::Ace::Base".constantize }.should.raise NameError
+    end
+    
+    it "should raise NameError for invalid string" do
+      lambda { "An invalid string".constantize }.should.raise NameError
+      lambda { "InvalidClass\n".constantize }.should.raise NameError
+    end
+    
+    it "should raise NameError for nested unknown constant in known constant" do
+      lambda { "Ace::ConstantizeTestCases".constantize }.should.raise NameError
+      lambda { "Ace::Base::ConstantizeTestCases".constantize }.should.raise NameError
+      lambda { "Ace::Gas::Base".constantize }.should.raise NameError
+      lambda { "Ace::Gas::ConstantizeTestCases".constantize }.should.raise NameError
+    end
+  end
+end

data/spec/motion-support/core_ext/time/acts_like_spec.rb

@@ -0,0 +1,11 @@
+describe "Time" do
+  describe "acts_like" do
+    it "should act like time" do
+      Time.now.should.acts_like(:time)
+    end
+    
+    it "should not act like date" do
+      Time.now.should.not.acts_like(:date)
+    end
+  end
+end

data/spec/motion-support/core_ext/time/calculation_spec.rb

@@ -0,0 +1,201 @@
+describe "Time" do
+  describe "calculations" do
+    describe "seconds_since_midnight" do
+      it "should calculate correctly" do
+        Time.local(2005,1,1,0,0,1).seconds_since_midnight.should == 1
+        Time.local(2005,1,1,0,1,0).seconds_since_midnight.should == 60
+        Time.local(2005,1,1,1,1,0).seconds_since_midnight.should == 3660
+        Time.local(2005,1,1,23,59,59).seconds_since_midnight.should == 86399
+        Time.local(2005,1,1,0,1,0,10).seconds_since_midnight.should == 60.00001
+      end
+    end
+    
+    describe "seconds_until_end_of_day" do
+      it "should calculate correctly" do
+        Time.local(2005,1,1,23,59,59).seconds_until_end_of_day.should == 0
+        Time.local(2005,1,1,23,59,58).seconds_until_end_of_day.should == 1
+        Time.local(2005,1,1,23,58,59).seconds_until_end_of_day.should == 60
+        Time.local(2005,1,1,22,58,59).seconds_until_end_of_day.should == 3660
+        Time.local(2005,1,1,0,0,0).seconds_until_end_of_day.should == 86399
+      end
+    end
+    
+    describe "beginning_of_day" do
+      it "should calculate correctly" do
+        Time.local(2005,2,4,10,10,10).beginning_of_day.should == Time.local(2005,2,4,0,0,0)
+      end
+    end
+    
+    describe "beginning_of_hour" do
+      it "should calculate correctly" do
+        Time.local(2005,2,4,19,30,10).beginning_of_hour.should == Time.local(2005,2,4,19,0,0)
+      end
+    end
+    
+    describe "beginning_of_minute" do
+      it "should calculate correctly" do
+        Time.local(2005,2,4,19,30,10).beginning_of_minute.should == Time.local(2005,2,4,19,30,0)
+      end
+    end
+    
+    describe "end_of_day" do
+      it "should calculate correctly" do
+        Time.local(2007,8,12,10,10,10).end_of_day.should == Time.local(2007,8,12,23,59,59,Rational(999999999, 1000))
+      end
+    end
+    
+    describe "end_of_hour" do
+      it "should calculate correctly" do
+        Time.local(2005,2,4,19,30,10).end_of_hour.should == Time.local(2005,2,4,19,59,59,Rational(999999999, 1000))
+      end
+    end
+    
+    describe "end_of_minute" do
+      it "should calculate correctly" do
+        Time.local(2005,2,4,19,30,10).end_of_minute.should == Time.local(2005,2,4,19,30,59,Rational(999999999, 1000))
+      end
+    end
+    
+    describe "last_year" do
+      it "should calculate correctly" do
+        Time.local(2005,6,5,10,0,0).last_year.should == Time.local(2004,6,5,10)
+      end
+    end
+    
+    describe "ago" do
+      it "should calculate correctly" do
+        Time.local(2005,2,22,10,10,10).ago(1).should == Time.local(2005,2,22,10,10,9)
+        Time.local(2005,2,22,10,10,10).ago(3600).should == Time.local(2005,2,22,9,10,10)
+        Time.local(2005,2,22,10,10,10).ago(86400*2).should == Time.local(2005,2,20,10,10,10)
+        Time.local(2005,2,22,10,10,10).ago(86400*2 + 3600 + 25).should == Time.local(2005,2,20,9,9,45)
+      end
+    end
+    
+    describe "since" do
+      it "should calculate correctly" do
+        Time.local(2005,2,22,10,10,10).since(1).should == Time.local(2005,2,22,10,10,11)
+        Time.local(2005,2,22,10,10,10).since(3600).should == Time.local(2005,2,22,11,10,10)
+        Time.local(2005,2,22,10,10,10).since(86400*2).should == Time.local(2005,2,24,10,10,10)
+        Time.local(2005,2,22,10,10,10).since(86400*2 + 3600 + 25).should == Time.local(2005,2,24,11,10,35)
+      end
+    end
+    
+    describe "change" do
+      it "should calculate correctly" do
+        Time.local(2005,2,22,15,15,10).change(:year => 2006).should == Time.local(2006,2,22,15,15,10)
+        Time.local(2005,2,22,15,15,10).change(:month => 6).should == Time.local(2005,6,22,15,15,10)
+        Time.local(2005,2,22,15,15,10).change(:year => 2012, :month => 9).should == Time.local(2012,9,22,15,15,10)
+        Time.local(2005,2,22,15,15,10).change(:hour => 16).should == Time.local(2005,2,22,16)
+        Time.local(2005,2,22,15,15,10).change(:hour => 16, :min => 45).should == Time.local(2005,2,22,16,45)
+        Time.local(2005,2,22,15,15,10).change(:min => 45).should == Time.local(2005,2,22,15,45)
+
+        Time.local(2005,1,2,11,22,33,44).change(:hour => 5).should == Time.local(2005,1,2,5,0,0,0)
+        Time.local(2005,1,2,11,22,33,44).change(:min => 6).should == Time.local(2005,1,2,11,6,0,0)
+        Time.local(2005,1,2,11,22,33,44).change(:sec => 7).should == Time.local(2005,1,2,11,22,7,0)
+        Time.local(2005,1,2,11,22,33,44).change(:usec => 8).should == Time.local(2005,1,2,11,22,33,8)
+      end
+    end
+    
+    describe "advance" do
+      it "should calculate correctly" do
+        Time.local(2005,2,28,15,15,10).advance(:years => 1).should == Time.local(2006,2,28,15,15,10)
+        Time.local(2005,2,28,15,15,10).advance(:months => 4).should == Time.local(2005,6,28,15,15,10)
+        Time.local(2005,2,28,15,15,10).advance(:weeks => 3).should == Time.local(2005,3,21,15,15,10)
+        Time.local(2005,2,28,15,15,10).advance(:weeks => 3.5).should == Time.local(2005,3,25,3,15,10)
+        Time.local(2005,2,28,15,15,10).advance(:days => 5).should == Time.local(2005,3,5,15,15,10)
+        Time.local(2005,2,28,15,15,10).advance(:days => 5.5).should == Time.local(2005,3,6,3,15,10)
+        Time.local(2005,2,28,15,15,10).advance(:years => 7, :months => 7).should == Time.local(2012,9,28,15,15,10)
+        Time.local(2005,2,28,15,15,10).advance(:years => 7, :months => 19, :days => 5).should == Time.local(2013,10,3,15,15,10)
+        Time.local(2005,2,28,15,15,10).advance(:years => 7, :months => 19, :weeks => 2, :days => 5).should == Time.local(2013,10,17,15,15,10)
+        Time.local(2005,2,28,15,15,10).advance(:years => -3, :months => -2, :days => -1).should == Time.local(2001,12,27,15,15,10)
+        Time.local(2004,2,29,15,15,10).advance(:years => 1).should == Time.local(2005,2,28,15,15,10)
+        Time.local(2005,2,28,15,15,10).advance(:hours => 5).should == Time.local(2005,2,28,20,15,10)
+        Time.local(2005,2,28,15,15,10).advance(:minutes => 7).should == Time.local(2005,2,28,15,22,10)
+        Time.local(2005,2,28,15,15,10).advance(:seconds => 9).should == Time.local(2005,2,28,15,15,19)
+        Time.local(2005,2,28,15,15,10).advance(:hours => 5, :minutes => 7, :seconds => 9).should == Time.local(2005,2,28,20,22,19)
+        Time.local(2005,2,28,15,15,10).advance(:hours => -5, :minutes => -7, :seconds => -9).should == Time.local(2005,2,28,10,8,1)
+        Time.local(2005,2,28,15,15,10).advance(:years => 7, :months => 19, :weeks => 2, :days => 5, :hours => 5, :minutes => 7, :seconds => 9).should == Time.local(2013,10,17,20,22,19)
+      end
+      
+      it "should advance with nsec" do
+        t = Time.at(0, Rational(108635108, 1000))
+        t.advance(:months => 0).should == t
+      end
+    end
+    
+    describe "days_in_month" do
+      it "should calculate with year" do
+        Time.days_in_month(1, 2005).should == 31
+
+        Time.days_in_month(2, 2005).should == 28
+        Time.days_in_month(2, 2004).should == 29
+        Time.days_in_month(2, 2000).should == 29
+        Time.days_in_month(2, 1900).should == 28
+
+        Time.days_in_month(3, 2005).should == 31
+        Time.days_in_month(4, 2005).should == 30
+        Time.days_in_month(5, 2005).should == 31
+        Time.days_in_month(6, 2005).should == 30
+        Time.days_in_month(7, 2005).should == 31
+        Time.days_in_month(8, 2005).should == 31
+        Time.days_in_month(9, 2005).should == 30
+        Time.days_in_month(10, 2005).should == 31
+        Time.days_in_month(11, 2005).should == 30
+        Time.days_in_month(12, 2005).should == 31
+      end
+      
+      it "should calculate for february in common year" do
+        Time.days_in_month(2, 2007).should == 28
+      end
+      
+      it "should calculate for february in leap year" do
+        Time.days_in_month(2, 2008).should == 29
+      end
+    end
+    
+    describe "last_month" do
+      it "should work on the 31st" do
+        Time.local(2004, 3, 31).last_month.should == Time.local(2004, 2, 29)
+      end
+    end
+    
+    describe "<=>" do
+      it "should compare with time" do
+        (Time.utc(2000) <=> Time.utc(1999, 12, 31, 23, 59, 59, 999)).should == 1
+        (Time.utc(2000) <=> Time.utc(2000, 1, 1, 0, 0, 0)).should == 0
+        (Time.utc(2000) <=> Time.utc(2000, 1, 1, 0, 0, 0, 001)).should == -1
+      end
+    end
+    
+    describe "all_day" do
+      it "should calculate correctly" do
+        Time.local(2011,6,7,10,10,10).all_day.should == (Time.local(2011,6,7,0,0,0)..Time.local(2011,6,7,23,59,59,Rational(999999999, 1000)))
+      end
+    end
+    
+    describe "all_week" do
+      it "should calculate correctly" do
+        Time.local(2011,6,7,10,10,10).all_week.should == (Time.local(2011,6,6,0,0,0)..Time.local(2011,6,12,23,59,59,Rational(999999999, 1000)))
+        Time.local(2011,6,7,10,10,10).all_week(:sunday).should == (Time.local(2011,6,5,0,0,0)..Time.local(2011,6,11,23,59,59,Rational(999999999, 1000)))
+      end
+    end
+    
+    describe "all_month" do
+      it "should calculate correctly" do
+        Time.local(2011,6,7,10,10,10).all_month.should == (Time.local(2011,6,1,0,0,0)..Time.local(2011,6,30,23,59,59,Rational(999999999, 1000)))
+      end
+    end
+    
+    describe "all_quarter" do
+      it "should calculate correctly" do
+        Time.local(2011,6,7,10,10,10).all_quarter.should == (Time.local(2011,4,1,0,0,0)..Time.local(2011,6,30,23,59,59,Rational(999999999, 1000)))
+      end
+    end
+    
+    describe "all_year" do
+      it "should calculate correctly" do
+        Time.local(2011,6,7,10,10,10).all_year.should == (Time.local(2011,1,1,0,0,0)..Time.local(2011,12,31,23,59,59,Rational(999999999, 1000)))
+      end
+    end
+  end
+end

data/spec/motion-support/core_ext/time/conversion_spec.rb

@@ -0,0 +1,54 @@
+describe "Time" do
+  describe "conversions" do
+    describe "to_formatted_s" do
+      before do
+        @time = Time.utc(2005, 2, 21, 17, 44, 30.12345678901)
+      end
+      
+      it "should use default conversion if no parameter is given" do
+        @time.to_s.should == @time.to_default_s
+      end
+      
+      it "should use default conversion if parameter is unknown" do
+        @time.to_s(:doesnt_exist).should == @time.to_default_s
+      end
+      
+      it "should convert to db format" do
+        @time.to_s(:db).should == "2005-02-21 17:44:30"
+      end
+      
+      it "should convert to short format" do
+        @time.to_s(:short).should == "21 Feb 17:44"
+      end
+      
+      it "should convert to time format" do
+        @time.to_s(:time).should == "17:44"
+      end
+      
+      it "should convert to number format" do
+        @time.to_s(:number).should == "20050221174430"
+      end
+      
+      it "should convert to nsec format" do
+        @time.to_s(:nsec).should == "200502211744309N"
+        # Hmm. Looks like RubyMotion has an issue with nanosecs in string time formatting. It should actually be "20050221174430123456789"
+      end
+      
+      it "should convert to long format" do
+        @time.to_s(:long).should == "February 21, 2005 17:44"
+      end
+      
+      it "should convert to long_ordinal format" do
+        @time.to_s(:long_ordinal).should == "February 21st, 2005 17:44"
+      end
+    end
+    
+    describe "custom date format" do
+      it "should convert to custom format" do
+        Time::DATE_FORMATS[:custom] = '%Y%m%d%H%M%S'
+        Time.local(2005, 2, 21, 14, 30, 0).to_s(:custom).should == '20050221143000'
+        Time::DATE_FORMATS.delete(:custom)
+      end
+    end
+  end
+end

data/spec/motion-support/duration_spec.rb

@@ -0,0 +1,107 @@
+describe "Duration" do
+  describe "threequals" do
+    it "should be a day" do
+      MotionSupport::Duration.should === 1.day
+    end
+    
+    it "should not be an int" do
+      MotionSupport::Duration.should.not === 1.day.to_i
+    end
+    
+    it "should not be a string" do
+      MotionSupport::Duration.should.not === 'foo'
+    end
+  end
+  
+  describe "equals" do
+    it "should equal itself" do
+      1.day.should == 1.day
+    end
+    
+    it "should equal integer representation" do
+      1.day.should == 1.day.to_i
+    end
+    
+    it "should not equal string" do
+      1.day.should.not == 'foo'
+    end
+  end
+  
+  describe "inspect" do
+    it "should convert to string representation" do
+      0.seconds.inspect.should == '0 seconds'
+      1.month.inspect.should == '1 month'
+      (1.month + 1.day).inspect.should == '1 month and 1 day'
+      (6.months - 2.days).inspect.should == '6 months and -2 days'
+      10.seconds.inspect.should == '10 seconds'
+      (10.years + 2.months + 1.day).inspect.should == '10 years, 2 months, and 1 day'
+      1.week.inspect.should == '7 days'
+      1.fortnight.inspect.should == '14 days'
+    end
+  end
+  
+  describe "arithmetic" do
+    it "should not break when subtracting time from itself" do
+      lambda { Date.today - Date.today }.should.not.raise
+    end
+
+    it "should add with time" do
+      (1.second + 1).should == 1 + 1.second
+    end
+
+    def test_plus_with_time
+      assert_equal 1 + 1.second, 1.second + 1, "Duration + Numeric should == Numeric + Duration"
+    end
+    
+  end
+  
+  describe "fractions" do
+    describe "days" do
+      it "should support fractional days" do
+        1.5.weeks.should == (86400 * 7) * 1.5
+        1.7.weeks.should == (86400 * 7) * 1.7
+      end
+      
+      it "should support since" do
+        t = 2.years.ago
+        1.5.days.since(t).should == 36.hours.since(t)
+      end
+      
+      it "should support ago" do
+        t = 2.years.ago
+        1.5.days.ago(t).should == 36.hours.ago(t)
+      end
+    end
+    
+    describe "weeks" do
+      it "should support fractional weeks" do
+        1.5.days.should == 86400 * 1.5
+        1.7.days.should == 86400 * 1.7
+      end
+      
+      it "should support since" do
+        t = 2.years.ago
+        1.5.weeks.since(t).should == (7 * 36).hours.since(t)
+      end
+      
+      it "should support ago" do
+        t = 2.years.ago
+        1.5.weeks.ago(t).should == (7 * 36).hours.ago(t)
+      end
+    end
+  end
+  
+  describe "delegation" do
+    it "should delegate with block" do
+      counter = 0
+      lambda { 1.minute.times { counter += 1 } }.should.not.raise
+      counter.should == 60
+    end
+  end
+  
+  describe "to_json" do
+    it "should convert to json" do
+      2.days.to_json.should == '172800'
+    end
+  end
+end