validates_timeliness 2.3.2 → 3.0.0.beta

data/spec/{formats_spec.rb → validates_timeliness/parser_spec.rb}

@@ -1,34 +1,34 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'spec_helper'
 
-describe ValidatesTimeliness::Formats do
+describe ValidatesTimeliness::Parser do
 
   describe "format proc generator" do
     it "should generate proc which outputs date array with values in correct order" do
-      generate_proc('yyyy-mm-dd').call('2000', '1', '2').should == [2000,1,2,0,0,0,0]
+      generate_method('yyyy-mm-dd').call('2000', '1', '2').should == [2000,1,2,0,0,0,0]
    end
 
     it "should generate proc which outputs date array from format with different order" do
-      generate_proc('dd/mm/yyyy').call('2', '1', '2000').should == [2000,1,2,0,0,0,0]
+      generate_method('dd/mm/yyyy').call('2', '1', '2000').should == [2000,1,2,0,0,0,0]
     end
 
     it "should generate proc which outputs time array" do
-      generate_proc('hh:nn:ss').call('01', '02', '03').should == [0,0,0,1,2,3,0]
+      generate_method('hh:nn:ss').call('01', '02', '03').should == [0,0,0,1,2,3,0]
     end
 
     it "should generate proc which outputs time array with meridian 'pm' adjusted hour" do
-      generate_proc('hh:nn:ss ampm').call('01', '02', '03', 'pm').should == [0,0,0,13,2,3,0]
+      generate_method('hh:nn:ss ampm').call('01', '02', '03', 'pm').should == [0,0,0,13,2,3,0]
     end
 
     it "should generate proc which outputs time array with meridian 'am' unadjusted hour" do
-      generate_proc('hh:nn:ss ampm').call('01', '02', '03', 'am').should == [0,0,0,1,2,3,0]
+      generate_method('hh:nn:ss ampm').call('01', '02', '03', 'am').should == [0,0,0,1,2,3,0]
     end
 
     it "should generate proc which outputs time array with microseconds" do
-      generate_proc('hh:nn:ss.u').call('01', '02', '03', '99').should == [0,0,0,1,2,3,990000]
+      generate_method('hh:nn:ss.u').call('01', '02', '03', '99').should == [0,0,0,1,2,3,990000]
     end
 
     it "should generate proc which outputs datetime array with zone offset" do
-      generate_proc('yyyy-mm-dd hh:nn:ss.u zo').call('2001', '02', '03', '04', '05', '06', '99', '+10:00').should == [2001,2,3,4,5,6,990000,36000]
+      generate_method('yyyy-mm-dd hh:nn:ss.u zo').call('2001', '02', '03', '04', '05', '06', '99', '+10:00').should == [2001,2,3,4,5,6,990000,36000]
     end
   end
 
@@ -95,115 +95,148 @@ describe ValidatesTimeliness::Formats do
     end
   end
 
-  describe "parse" do
+  describe "_parse" do
 
     it "should return time array from date string" do
-      time_array = formats.parse('12:13:14', :time, :strict => true)
+      time_array = formats._parse('12:13:14', :time, :strict => true)
       time_array.should == [2000,1,1,12,13,14,0]
     end
 
     it "should return nil if time hour is out of range for AM meridian" do
-      time_array = formats.parse('13:14 am', :time, :strict => true)
+      time_array = formats._parse('13:14 am', :time, :strict => true)
       time_array.should == nil
-      time_array = formats.parse('00:14 am', :time, :strict => true)
+      time_array = formats._parse('00:14 am', :time, :strict => true)
       time_array.should == nil
     end
 
     it "should return date array from time string" do
-      time_array = formats.parse('2000-02-01', :date, :strict => true)
+      time_array = formats._parse('2000-02-01', :date, :strict => true)
       time_array.should == [2000,2,1,0,0,0,0]
     end
 
     it "should return datetime array from string value" do
-      time_array = formats.parse('2000-02-01 12:13:14', :datetime, :strict => true)
+      time_array = formats._parse('2000-02-01 12:13:14', :datetime, :strict => true)
       time_array.should == [2000,2,1,12,13,14,0]
     end
 
     it "should parse date string when type is datetime" do
-      time_array = formats.parse('2000-02-01', :datetime, :strict => false)
+      time_array = formats._parse('2000-02-01', :datetime, :strict => false)
       time_array.should == [2000,2,1,0,0,0,0]
     end
 
     it "should ignore time when extracting date and strict is false" do
-      time_array = formats.parse('2000-02-01 12:13', :date, :strict => false)
+      time_array = formats._parse('2000-02-01 12:13', :date, :strict => false)
       time_array.should == [2000,2,1,0,0,0,0]
     end
 
     it "should ignore time when extracting date from format with trailing year and strict is false" do
-      time_array = formats.parse('01-02-2000 12:13', :date, :strict => false)
+      time_array = formats._parse('01-02-2000 12:13', :date, :strict => false)
       time_array.should == [2000,2,1,0,0,0,0]
     end
 
     it "should ignore date when extracting time and strict is false" do
-      time_array = formats.parse('2000-02-01 12:13', :time, :strict => false)
+      time_array = formats._parse('2000-02-01 12:13', :time, :strict => false)
       time_array.should == [2000,1,1,12,13,0,0]
     end
 
     it "should return zone offset when :include_offset option is true" do
-      time_array = formats.parse('2000-02-01T12:13:14-10:30', :datetime, :include_offset => true)
+      time_array = formats._parse('2000-02-01T12:13:14-10:30', :datetime, :include_offset => true)
       time_array.should == [2000,2,1,12,13,14,0,-37800]
     end
-  end
 
-  describe "parse with format option" do
-    it "should return values if string matches specified format" do
-      time_array = formats.parse('2000-02-01 12:13:14', :datetime, :format => 'yyyy-mm-dd hh:nn:ss')
-      time_array.should == [2000,2,1,12,13,14,0]
-    end
+    context "with format option" do
+      it "should return values if string matches specified format" do
+        time_array = formats._parse('2000-02-01 12:13:14', :datetime, :format => 'yyyy-mm-dd hh:nn:ss')
+        time_array.should == [2000,2,1,12,13,14,0]
+      end
 
-    it "should return nil if string does not match specified format" do
-      time_array = formats.parse('2000-02-01 12:13', :datetime, :format => 'yyyy-mm-dd hh:nn:ss')
-      time_array.should be_nil
+      it "should return nil if string does not match specified format" do
+        time_array = formats._parse('2000-02-01 12:13', :datetime, :format => 'yyyy-mm-dd hh:nn:ss')
+        time_array.should be_nil
+      end
     end
-  end
 
-  describe "parsing date with ambiguous year" do
-    it "should return year in current century if year below threshold" do
-      time_array = formats.parse('01-02-29', :date)
-      time_array.should == [2029,2,1,0,0,0,0]
-    end
+    context "date with ambiguous year" do
+      it "should return year in current century if year below threshold" do
+        time_array = formats._parse('01-02-29', :date)
+        time_array.should == [2029,2,1,0,0,0,0]
+      end
 
-    it "should return year in last century if year at or above threshold" do
-      time_array = formats.parse('01-02-30', :date)
-      time_array.should == [1930,2,1,0,0,0,0]
+      it "should return year in last century if year at or above threshold" do
+        time_array = formats._parse('01-02-30', :date)
+        time_array.should == [1930,2,1,0,0,0,0]
+      end
+
+      it "should allow custom threshold" do
+        default = ValidatesTimeliness::Parser.ambiguous_year_threshold
+        ValidatesTimeliness::Parser.ambiguous_year_threshold = 40
+        time_array = formats._parse('01-02-39', :date)
+        time_array.should == [2039,2,1,0,0,0,0]
+        time_array = formats._parse('01-02-40', :date)
+        time_array.should == [1940,2,1,0,0,0,0]
+        ValidatesTimeliness::Parser.ambiguous_year_threshold = default
+      end
     end
 
-    it "should allow custom threshold" do
-      default = ValidatesTimeliness::Formats.ambiguous_year_threshold
-      ValidatesTimeliness::Formats.ambiguous_year_threshold = 40
-      time_array = formats.parse('01-02-39', :date)
-      time_array.should == [2039,2,1,0,0,0,0]
-      time_array = formats.parse('01-02-40', :date)
-      time_array.should == [1940,2,1,0,0,0,0]
-      ValidatesTimeliness::Formats.ambiguous_year_threshold = default
+    context "with custom dummy date values" do
+      before(:all) do
+        @old_dummy_date = ValidatesTimeliness.dummy_date_for_time_type
+        ValidatesTimeliness.dummy_date_for_time_type = [2009,1,1]
+      end
+
+      it "should return time array with custom dummy date" do
+        time_array = formats._parse('12:13:14', :time, :strict => true)
+        time_array.should == [2009,1,1,12,13,14,0]
+      end
+
+      after(:all) do
+        ValidatesTimeliness.dummy_date_for_time_type = @old_dummy_date
+      end
     end
   end
 
-  describe "parse with custom dummy date values" do
-    before(:all) do
-      @old_dummy_date = formats.dummy_date_for_time_type
-      formats.dummy_date_for_time_type = [2009,1,1]
+  describe "parse" do
+    it "should return time object for valid time string" do
+      parse("2000-01-01 12:13:14", :datetime).should be_kind_of(Time)
     end
-
-    it "should return time array with custom dummy date" do
-      time_array = formats.parse('12:13:14', :time, :strict => true)
-      time_array.should == [2009,1,1,12,13,14,0]
+    
+    it "should return nil for time string with invalid date part" do
+      parse("2000-02-30 12:13:14", :datetime).should be_nil
+    end
+    
+    it "should return nil for time string with invalid time part" do
+      parse("2000-02-01 25:13:14", :datetime).should be_nil      
+    end
+    
+    it "should return Time object when passed a Time object" do
+      parse(Time.now, :datetime).should be_kind_of(Time)
+    end
+        
+    it "should convert time string into current timezone" do
+      Time.zone = 'Melbourne'
+      time = parse("2000-01-01 12:13:14", :datetime, :timezone_aware => true)
+      Time.zone.utc_offset.should == 10.hours
     end
 
-    after(:all) do
-      formats.dummy_date_for_time_type = @old_dummy_date
+    it "should return nil for invalid date string" do
+      parse("2000-02-30", :date).should be_nil      
+    end
+        
+    def parse(*args)
+      ValidatesTimeliness::Parser.parse(*args)
     end
   end
 
-  describe "parse ISO8601 datetime" do
-    it "should return array without zone offset when no offset in string" do
-      time_array = formats.parse('2000-02-01T12:13:14Z', :datetime, :strict => true)
-      time_array.should == [2000,2,1,12,13,14,0]
+  describe "make_time" do
+    it "should create time using current timezone" do
+      time = ValidatesTimeliness::Parser.make_time([2000,1,1,12,0,0])
+      time.zone.should == "UTC"
     end
 
-    it "should return array with zone offset when offset in string" do
-      time_array = formats.parse('2000-02-01T12:13:14+10:00', :datetime, :strict => true)
-      time_array.should == [2000,2,1,12,13,14,0,36000]
+    it "should create time using current timezone" do
+      Time.zone = 'Melbourne'
+      time = ValidatesTimeliness::Parser.make_time([2000,1,1,12,0,0], true)
+      time.zone.should == "EST"
     end
   end
 
@@ -248,7 +281,7 @@ describe ValidatesTimeliness::Formats do
     it "should add format before specified format and be higher precedence" do
       formats.add_formats(:time, "ss:hh:nn", :before => 'hh:nn:ss')
       validate("59:23:58", :time).should be_true
-      time_array = formats.parse('59:23:58', :time)
+      time_array = formats._parse('59:23:58', :time)
       time_array.should == [2000,1,1,23,58,59,0]
     end
 
@@ -269,10 +302,10 @@ describe ValidatesTimeliness::Formats do
 
   describe "removing US formats" do
     it "should validate a date as European format when US formats removed" do
-      time_array = formats.parse('01/02/2000', :date)
+      time_array = formats._parse('01/02/2000', :date)
       time_array.should == [2000, 1, 2,0,0,0,0]
       formats.remove_us_formats
-      time_array = formats.parse('01/02/2000', :date)
+      time_array = formats._parse('01/02/2000', :date)
       time_array.should == [2000, 2, 1,0,0,0,0]
     end
 
@@ -283,7 +316,7 @@ describe ValidatesTimeliness::Formats do
 
 
   def formats
-    ValidatesTimeliness::Formats
+    ValidatesTimeliness::Parser
   end
 
   def validate(time_string, type)
@@ -296,15 +329,16 @@ describe ValidatesTimeliness::Formats do
 
   def generate_regexp(format)
     # wrap in line start and end anchors to emulate extract values method
-    /\A#{formats.send(:generate_format_expression, format)[0]}\Z/
+    /\A#{formats.send(:generate_format_expression, format)}\Z/
   end
 
   def generate_regexp_str(format)
-    formats.send(:generate_format_expression, format)[0].inspect
+    formats.send(:generate_format_expression, format).inspect
   end
 
-  def generate_proc(format)
-    formats.send(:generate_format_expression, format)[1]
+  def generate_method(format)
+    formats.send(:generate_format_expression, format)
+    ValidatesTimeliness::Parser.method(:"format_#{format}")
   end
 
   def delete_format(type, format)

data/spec/validates_timeliness/validator/after_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe ValidatesTimeliness::Validator, ":after option" do
+  include ModelHelpers 
+
+  describe "for date type" do
+    before do
+      Person.validates_date :birth_date, :after => Date.new(2010, 1, 1)
+    end
+
+    it "should not be valid for same date value" do
+      invalid!(:birth_date, Date.new(2010, 1, 1), 'must be after 2010-01-01')
+    end
+
+    it "should not be valid for date before restriction" do
+      invalid!(:birth_date, Date.new(2009, 12, 31), 'must be after 2010-01-01')
+    end
+
+    it "should be valid for date after restriction" do
+      valid!(:birth_date, Date.new(2010, 1, 2))
+    end
+  end
+
+  describe "for time type" do
+    before do
+      Person.validates_time :birth_time, :after => Time.mktime(2000, 1, 1, 12, 0, 0)
+    end
+
+    it "should not be valid for same time as restriction" do
+      invalid!(:birth_time, Time.local_time(2000, 1, 1, 12, 0, 0), 'must be after 12:00:00')
+    end
+
+    it "should not be valid for time before restriction" do
+      invalid!(:birth_time, Time.local_time(2000, 1, 1, 11, 59, 59), 'must be after 12:00:00')
+    end
+
+    it "should be valid for time after restriction" do
+      valid!(:birth_time, Time.local_time(2000, 1, 1, 12, 00, 01))
+    end
+  end
+
+  describe "for datetime type" do
+    before do
+      Person.validates_datetime :birth_datetime, :after => DateTime.civil_from_format(:local, 2010, 1, 1, 12, 0, 0)
+    end
+
+    it "should not be valid for same datetime as restriction" do
+      invalid!(:birth_datetime, DateTime.civil_from_format(:local, 2010, 1, 1, 12, 0, 0), 'must be after 2010-01-01 12:00:00')
+    end
+
+    it "should be valid for datetime is before restriction" do
+      invalid!(:birth_datetime, DateTime.civil_from_format(:local, 2010, 1, 1, 11, 59, 59), 'must be after 2010-01-01 12:00:00')
+    end
+
+    it "should be valid for datetime is after restriction" do
+      valid!(:birth_datetime, DateTime.civil_from_format(:local, 2010, 1, 1, 12, 0, 1))
+    end
+  end
+end

data/spec/validates_timeliness/validator/before_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe ValidatesTimeliness::Validator, ":before option" do
+  include ModelHelpers 
+
+  describe "for date type" do
+    before do
+      Person.validates_date :birth_date, :before => Date.new(2010, 1, 1)
+    end
+
+    it "should not be valid for date after restriction" do
+      invalid!(:birth_date, Date.new(2010, 1, 2), 'must be before 2010-01-01')
+    end
+
+    it "should not be valid for same date value" do
+      invalid!(:birth_date, Date.new(2010, 1, 1), 'must be before 2010-01-01')
+    end
+
+    it "should be valid for date before restriction" do
+      valid!(:birth_date, Date.new(2009, 12, 31))
+    end
+  end
+
+  describe "for time type" do
+    before do
+      Person.validates_time :birth_time, :before => Time.mktime(2000, 1, 1, 12, 0, 0)
+    end
+
+    it "should not be valid for time after restriction" do
+      invalid!(:birth_time, Time.local_time(2000, 1, 1, 12, 00, 01), 'must be before 12:00:00')
+    end
+
+    it "should not be valid for same time as restriction" do
+      invalid!(:birth_time, Time.local_time(2000, 1, 1, 12, 0, 0), 'must be before 12:00:00')
+    end
+
+    it "should be valid for time before restriction" do
+      valid!(:birth_time, Time.local_time(2000, 1, 1, 11, 59, 59))
+    end
+  end
+
+  describe "for datetime type" do
+    before do
+      Person.validates_datetime :birth_datetime, :before => DateTime.civil_from_format(:local, 2010, 1, 1, 12, 0, 0)
+    end
+
+    it "should not be valid for datetime after restriction" do
+      invalid!(:birth_datetime, DateTime.civil_from_format(:local, 2010, 1, 1, 12, 0, 1), 'must be before 2010-01-01 12:00:00')
+    end
+
+    it "should not be valid for same datetime as restriction" do
+      invalid!(:birth_datetime, DateTime.civil_from_format(:local, 2010, 1, 1, 12, 0, 0), 'must be before 2010-01-01 12:00:00')
+    end
+
+    it "should be valid for datetime before restriction" do
+      valid!(:birth_datetime, DateTime.civil_from_format(:local, 2010, 1, 1, 11, 59, 59))
+    end
+  end
+end

data/spec/validates_timeliness/validator/is_at_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe ValidatesTimeliness::Validator, ":is_at option" do
+  include ModelHelpers 
+
+  before do
+    Timecop.freeze(Time.local_time(2010, 1, 1, 0, 0, 0))
+  end
+
+  describe "for date type" do
+    before do
+      Person.validates_date :birth_date, :is_at => Date.new(2010, 1, 1)
+    end
+
+    it "should not be valid for date before restriction" do
+      invalid!(:birth_date, Date.new(2009, 12, 31), 'must be at 2010-01-01')
+    end
+
+    it "should not be valid for date after restriction" do
+      invalid!(:birth_date, Date.new(2010, 1, 2), 'must be at 2010-01-01')
+    end
+
+    it "should be valid for same date value" do
+      valid!(:birth_date, Date.new(2010, 1, 1))
+    end
+  end
+
+  describe "for time type" do
+    before do
+      Person.validates_time :birth_time, :is_at => Time.mktime(2000, 1, 1, 12, 0, 0)
+    end
+
+    it "should not be valid for time before restriction" do
+      invalid!(:birth_time, Time.local_time(2000, 1, 1, 11, 59, 59), 'must be at 12:00:00')
+    end
+
+    it "should not be valid for time after restriction" do
+      invalid!(:birth_time, Time.local_time(2000, 1, 1, 12, 00, 01), 'must be at 12:00:00')
+    end
+
+    it "should be valid for same time as restriction" do
+      valid!(:birth_time, Time.local_time(2000, 1, 1, 12, 0, 0))
+    end
+  end
+
+  describe "for datetime type" do
+    before do
+      Person.validates_datetime :birth_datetime, :is_at => DateTime.civil_from_format(:local, 2010, 1, 1, 12, 0, 0)
+    end
+
+    it "should not be valid for datetime before restriction" do
+      invalid!(:birth_datetime, DateTime.civil_from_format(:local, 2010, 1, 1, 11, 59, 59), 'must be at 2010-01-01 12:00:00')
+    end
+
+    it "should not be valid for datetime after restriction" do
+      invalid!(:birth_datetime, DateTime.civil_from_format(:local, 2010, 1, 1, 12, 0, 1), 'must be at 2010-01-01 12:00:00')
+    end
+
+    it "should be valid for same datetime as restriction" do
+      valid!(:birth_datetime, DateTime.civil_from_format(:local, 2010, 1, 1, 12, 0, 0))
+    end
+  end
+end