adzap-validates_timeliness 1.1.1

data/spec/active_record/attribute_methods_spec.rb

@@ -0,0 +1,204 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe ValidatesTimeliness::ActiveRecord::AttributeMethods do
+  include ValidatesTimeliness::ActiveRecord::AttributeMethods
+  include ValidatesTimeliness::ValidationMethods
+  
+  before do
+    @person = Person.new
+  end
+
+  it "should call write_date_time_attribute when date attribute assigned value" do
+    @person.should_receive(:write_date_time_attribute)
+    @person.birth_date = "2000-01-01"
+  end
+
+  it "should call write_date_time_attribute when time attribute assigned value" do
+    @person.should_receive(:write_date_time_attribute)
+    @person.birth_time = "12:00"
+  end
+
+  it "should call write_date_time_attribute when datetime attribute assigned value" do
+    @person.should_receive(:write_date_time_attribute)
+    @person.birth_date_and_time = "2000-01-01 12:00"
+  end
+
+  it "should call parser on write for datetime attribute" do
+    @person.class.should_receive(:parse_date_time).once
+    @person.birth_date_and_time = "2000-01-01 02:03:04"
+  end
+
+  it "should call parser on write for date attribute" do
+    @person.class.should_receive(:parse_date_time).once
+    @person.birth_date = "2000-01-01"
+  end
+
+  it "should call parser on write for time attribute" do
+    @person.class.should_receive(:parse_date_time).once
+    @person.birth_time = "12:00"
+  end
+
+  it "should return raw string value for attribute_before_type_cast when written as string" do
+    time_string = "2000-01-01 02:03:04"
+    @person.birth_date_and_time = time_string
+    @person.birth_date_and_time_before_type_cast.should == time_string
+  end
+  
+  it "should return Time object for attribute_before_type_cast when written as Time" do
+    @person.birth_date_and_time = Time.mktime(2000, 1, 1, 2, 3, 4)
+    @person.birth_date_and_time_before_type_cast.should be_kind_of(Time)
+  end
+
+  it "should return Time object for datetime attribute read method when assigned Time object" do
+    @person.birth_date_and_time = Time.now
+    @person.birth_date_and_time.should be_kind_of(Time)
+  end
+
+  it "should return Time object for datetime attribute read method when assigned string" do
+    @person.birth_date_and_time = "2000-01-01 02:03:04"
+    @person.birth_date_and_time.should be_kind_of(Time)
+  end    
+ 
+  it "should return Date object for date attribute read method when assigned Date object" do
+    @person.birth_date = Date.today
+    @person.birth_date.should be_kind_of(Date)
+  end  
+ 
+  it "should return Date object for date attribute read method when assigned string" do
+    @person.birth_date = '2000-01-01'
+    @person.birth_date.should be_kind_of(Date)
+  end 
+ 
+  it "should return nil when time is invalid" do
+    @person.birth_date_and_time = "2000-01-32 02:03:04"
+    @person.birth_date_and_time.should be_nil
+  end
+
+  it "should not save invalid date value to database" do        
+    time_string = "2000-01-32 02:03:04"
+    @person = Person.new
+    @person.birth_date_and_time = time_string
+    @person.save
+    @person.reload
+    @person.birth_date_and_time_before_type_cast.should be_nil
+  end
+  
+  unless RAILS_VER < '2.1'
+    it "should return stored time string as Time with correct timezone" do
+      Time.zone = 'Melbourne'
+      time_string = "2000-06-01 02:03:04"
+      @person.birth_date_and_time = time_string
+      @person.birth_date_and_time.strftime('%Y-%m-%d %H:%M:%S %Z %z').should == time_string + ' EST +1000'
+    end
+
+    it "should return time object from database in correct timezone" do        
+      Time.zone = 'Melbourne'
+      time_string = "2000-06-01 09:00:00"
+      @person = Person.new
+      @person.birth_date_and_time = time_string
+      @person.save
+      @person.reload
+      @person.birth_date_and_time.strftime('%Y-%m-%d %H:%M:%S %Z %z').should == time_string + ' EST +1000'
+    end
+    
+    describe "dirty attributes" do
+    
+      it "should return true for attribute changed? when value updated" do
+        time_string = "2000-01-01 02:03:04"
+        @person.birth_date_and_time = time_string
+        @person.birth_date_and_time_changed?.should be_true
+      end
+    
+      it "should show changes when time attribute changed from nil to Time object" do
+        time_string = "2000-01-01 02:03:04"
+        @person.birth_date_and_time = time_string
+        time = @person.birth_date_and_time
+        @person.changes.should == {"birth_date_and_time" => [nil, time]}
+      end
+      
+      it "should show changes when time attribute changed from Time object to nil" do
+        time_string = "2020-01-01 02:03:04"
+        @person.birth_date_and_time = time_string
+        @person.save false
+        @person.reload
+        time = @person.birth_date_and_time
+        @person.birth_date_and_time = nil
+        @person.changes.should == {"birth_date_and_time" => [time, nil]}
+      end
+      
+      it "should show no changes when assigned same value as Time object" do
+        time_string = "2020-01-01 02:03:04"
+        @person.birth_date_and_time = time_string
+        @person.save false
+        @person.reload
+        time = @person.birth_date_and_time
+        @person.birth_date_and_time = time
+        @person.changes.should == {}
+      end
+      
+      it "should show no changes when assigned same value as time string" do
+        time_string = "2020-01-01 02:03:04"
+        @person.birth_date_and_time = time_string
+        @person.save false
+        @person.reload
+        @person.birth_date_and_time = time_string
+        @person.changes.should == {}
+      end
+      
+    end
+  else
+    
+    it "should return time object from database in default timezone" do        
+      ActiveRecord::Base.default_timezone = :utc
+      time_string = "2000-01-01 09:00:00"
+      @person = Person.new
+      @person.birth_date_and_time = time_string
+      @person.save
+      @person.reload
+      @person.birth_date_and_time.strftime('%Y-%m-%d %H:%M:%S %Z').should == time_string + ' GMT'
+    end
+      
+  end
+  
+  it "should return same time object on repeat reads on existing object" do
+    Time.zone = 'Melbourne' unless RAILS_VER < '2.1'
+    time_string = "2000-01-01 09:00:00"
+    @person = Person.new
+    @person.birth_date_and_time = time_string
+    @person.save!
+    @person.reload
+    time = @person.birth_date_and_time
+    @person.birth_date_and_time.should == time
+  end
+  
+  it "should return same date object on repeat reads on existing object" do
+    date_string = Date.today
+    @person = Person.new
+    @person.birth_date = date_string
+    @person.save!
+    @person.reload
+    date = @person.birth_date
+    @person.birth_date.should == date
+  end
+  
+  it "should return correct date value after new value assigned" do
+    today = Date.today
+    tomorrow = Date.today + 1.day    
+    @person = Person.new
+    @person.birth_date = today
+    @person.birth_date.should == today
+    @person.birth_date = tomorrow
+    @person.birth_date.should == tomorrow
+  end
+ 
+  it "should update date attribute on existing object" do
+    today = Date.today
+    tomorrow = Date.today + 1.day
+    @person = Person.create(:birth_date => today)
+    @person.birth_date = tomorrow
+    @person.save!
+    @person.reload
+    @person.birth_date.should == tomorrow
+  end
+ 
+end

data/spec/active_record/multiparameter_attributes_spec.rb

@@ -0,0 +1,48 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe ValidatesTimeliness::ActiveRecord::MultiparameterAttributes do
+  def obj
+    @obj ||= Person.new
+  end
+
+  it "should convert array for datetime type into datetime string" do
+    time_string = obj.time_array_to_string([2000,2,1,9,10,11], :datetime)
+    time_string.should == "2000-02-01 09:10:11"
+  end
+  
+  it "should convert array for date type into date string" do
+    time_string = obj.time_array_to_string([2000,2,1], :date)
+    time_string.should == "2000-02-01"
+  end
+  
+  it "should convert array for time type into time string" do
+    time_string = obj.time_array_to_string([2000,1,1,9,10,11], :time)
+    time_string.should == "09:10:11"
+  end
+  
+  describe "execute_callstack_for_multiparameter_attributes" do 
+    before do      
+      @callstack = {
+        'birth_date_and_time' => [2000,2,1,9,10,11],
+        'birth_date' => [2000,2,1,9,10,11],
+        'birth_time' => [2000,2,1,9,10,11]
+      }
+    end
+    
+    it "should store datetime string for datetime column" do      
+      obj.should_receive(:birth_date_and_time=).once.with("2000-02-01 09:10:11")
+      obj.send(:execute_callstack_for_multiparameter_attributes, @callstack)
+    end    
+    
+    it "should store date string for a date column" do
+      obj.should_receive(:birth_date=).once.with("2000-02-01")
+      obj.send(:execute_callstack_for_multiparameter_attributes, @callstack)
+    end
+   
+    it "should store time string for a time column" do
+      obj.should_receive(:birth_time=).once.with("09:10:11")
+      obj.send(:execute_callstack_for_multiparameter_attributes, @callstack)
+    end
+  end
+  
+end

data/spec/core_ext/dummy_time_spec.rb

@@ -0,0 +1,31 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe ValidatesTimeliness::CoreExtensions::Date do  
+  before do
+    @a_date = Date.new(2008, 7, 1)
+  end
+  
+  it "should make a date value into a dummy time value" do
+    @a_date.to_dummy_time.should == Time.utc(2000,1,1,0,0,0)
+  end
+end
+
+describe ValidatesTimeliness::CoreExtensions::Time do
+  before do
+    @a_time = Time.mktime(2008, 7, 1, 2, 3, 4)
+  end
+  
+  it "should make a time value into a dummy time value" do
+    @a_time.to_dummy_time.should == Time.utc(2000,1,1,2,3,4)
+  end
+end
+
+describe ValidatesTimeliness::CoreExtensions::DateTime do
+  before do
+    @a_datetime = DateTime.new(2008, 7, 1, 2, 3, 4)
+  end
+  
+  it "should make a datetime value into a dummy time value" do
+    @a_datetime.to_dummy_time.should == Time.utc(2000,1,1,2,3,4)
+  end
+end

data/spec/formats_spec.rb

@@ -0,0 +1,274 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe ValidatesTimeliness::Formats do
+  attr_reader :formats
+  
+  before do
+   @formats = ValidatesTimeliness::Formats
+  end
+  
+  describe "expression generator" do
+    it "should generate regexp for time" do
+      generate_regexp_str('hh:nn:ss').should == '/(\d{2}):(\d{2}):(\d{2})/'
+    end
+    
+    it "should generate regexp for time with meridian" do
+      generate_regexp_str('hh:nn:ss ampm').should == '/(\d{2}):(\d{2}):(\d{2}) ((?:[aApP])\.?[mM]\.?)/'
+    end
+    
+    it "should generate regexp for time with meridian and optional space between" do
+      generate_regexp_str('hh:nn:ss_ampm').should == '/(\d{2}):(\d{2}):(\d{2})\s?((?:[aApP])\.?[mM]\.?)/'
+    end
+    
+    it "should generate regexp for time with single or double digits" do
+      generate_regexp_str('h:n:s').should == '/(\d{1,2}):(\d{1,2}):(\d{1,2})/'
+    end
+    
+    it "should generate regexp for date" do
+      generate_regexp_str('yyyy-mm-dd').should == '/(\d{4})-(\d{2})-(\d{2})/'
+    end
+    
+    it "should generate regexp for date with slashes" do
+      generate_regexp_str('dd/mm/yyyy').should == '/(\d{2})\/(\d{2})\/(\d{4})/'
+    end
+   
+    it "should generate regexp for date with dots" do
+      generate_regexp_str('dd.mm.yyyy').should == '/(\d{2})\.(\d{2})\.(\d{4})/'
+    end
+   
+    it "should generate regexp for Ruby time string" do
+      expected = '/(\w{3,9}) (\w{3,9}) (\d{2}):(\d{2}):(\d{2}) (?:[+-]\d{2}:?\d{2}) (\d{4})/'
+      generate_regexp_str('ddd mmm hh:nn:ss zo yyyy').should == expected
+    end
+    
+    it "should generate regexp for iso8601 datetime" do
+      expected = '/(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:Z|(?:[+-]\d{2}:?\d{2}))/'
+      generate_regexp_str('yyyy-mm-ddThh:nn:ss(?:Z|zo)').should == expected
+    end
+  end
+ 
+  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]
+    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]
+    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]
+    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]
+    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]
+    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]
+    end
+  end
+  
+  describe "validation regexps" do
+  
+    describe "for time formats" do
+      format_tests = {  
+        'hh:nn:ss'  => {:pass => ['12:12:12', '01:01:01'], :fail => ['1:12:12', '12:1:12', '12:12:1', '12-12-12']},
+        'hh-nn-ss'  => {:pass => ['12-12-12', '01-01-01'], :fail => ['1-12-12', '12-1-12', '12-12-1', '12:12:12']},
+        'h:nn'      => {:pass => ['12:12', '1:01'], :fail => ['12:2', '12-12']},
+        'h.nn'      => {:pass => ['2.12', '12.12'], :fail => ['2.1', '12:12']},
+        'h nn'      => {:pass => ['2 12', '12 12'], :fail => ['2 1', '2.12', '12:12']},
+        'h-nn'      => {:pass => ['2-12', '12-12'], :fail => ['2-1', '2.12', '12:12']},
+        'h:nn_ampm' => {:pass => ['2:12am', '2:12 pm', '2:12 AM', '2:12PM'], :fail => ['1:2am', '1:12  pm', '2.12am']},
+        'h.nn_ampm' => {:pass => ['2.12am', '2.12 pm'], :fail => ['1:2am', '1:12  pm', '2:12am']},
+        'h nn_ampm' => {:pass => ['2 12am', '2 12 pm'], :fail => ['1 2am', '1 12  pm', '2:12am']},
+        'h-nn_ampm' => {:pass => ['2-12am', '2-12 pm'], :fail => ['1-2am', '1-12  pm', '2:12am']},
+        'h_ampm'    => {:pass => ['2am', '2 am', '12 pm'], :fail => ['1.am', '12  pm', '2:12am']},
+      }
+      format_tests.each do |format, values|
+        it "should correctly validate times in format '#{format}'" do
+          regexp = generate_regexp(format)
+          values[:pass].each {|value| value.should match(regexp)}
+          values[:fail].each {|value| value.should_not match(regexp)}
+        end
+      end      
+    end
+    
+    describe "for date formats" do
+      format_tests = {
+        'yyyy/mm/dd' => {:pass => ['2000/02/01'], :fail => ['2000\02\01', '2000/2/1', '00/02/01']},
+        'yyyy-mm-dd' => {:pass => ['2000-02-01'], :fail => ['2000\02\01', '2000-2-1', '00-02-01']},
+        'yyyy.mm.dd' => {:pass => ['2000.02.01'], :fail => ['2000\02\01', '2000.2.1', '00.02.01']},
+        'm/d/yy'     => {:pass => ['2/1/01', '02/01/00', '02/01/2000'], :fail => ['2/1/0', '2.1.01']},
+        'd/m/yy'     => {:pass => ['1/2/01', '01/02/00', '01/02/2000'], :fail => ['1/2/0', '1.2.01']},
+        'm\d\yy'     => {:pass => ['2\1\01', '2\01\00', '02\01\2000'], :fail => ['2\1\0', '2/1/01']},
+        'd\m\yy'     => {:pass => ['1\2\01', '1\02\00', '01\02\2000'], :fail => ['1\2\0', '1/2/01']},
+        'd-m-yy'     => {:pass => ['1-2-01', '1-02-00', '01-02-2000'], :fail => ['1-2-0', '1/2/01']},
+        'd.m.yy'     => {:pass => ['1.2.01', '1.02.00', '01.02.2000'], :fail => ['1.2.0', '1/2/01']},
+        'd mmm yy'   => {:pass => ['1 Feb 00', '1 Feb 2000', '1 February 00', '01 February 2000'], 
+                          :fail => ['1 Fe 00', 'Feb 1 2000', '1 Feb 0']}
+      }    
+      format_tests.each do |format, values|      
+        it "should correctly validate dates in format '#{format}'" do
+          regexp = generate_regexp(format)
+          values[:pass].each {|value| value.should match(regexp)}
+          values[:fail].each {|value| value.should_not match(regexp)}
+        end
+      end      
+    end
+    
+    describe "for datetime formats" do
+      format_tests = {
+        'ddd mmm d hh:nn:ss zo yyyy'  => {:pass => ['Sat Jul 19 12:00:00 +1000 2008'], :fail => []},
+        'yyyy-mm-ddThh:nn:ss(?:Z|zo)' => {:pass => ['2008-07-19T12:00:00+10:00', '2008-07-19T12:00:00Z'], :fail => ['2008-07-19T12:00:00Z+10:00']},
+      }    
+      format_tests.each do |format, values|      
+        it "should correctly validate datetimes in format '#{format}'" do
+          regexp = generate_regexp(format)
+          values[:pass].each {|value| value.should match(regexp)}
+          values[:fail].each {|value| value.should_not match(regexp)}
+        end
+      end      
+    end
+  end
+  
+  describe "extracting values" do
+    
+    it "should return time array from date string" do
+      time_array = formats.parse('12:13:14', :time, true)
+      time_array.should == [0,0,0,12,13,14,0]
+    end
+    
+    it "should return date array from time string" do
+      time_array = formats.parse('2000-02-01', :date, 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, 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, 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:12', :date, 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:12', :time, false)
+      time_array.should == [0,0,0,12,12,0,0]
+    end
+  end
+  
+  describe "removing formats" do
+    before do
+      formats.compile_format_expressions
+    end
+    
+    it "should remove format from format array" do      
+      formats.remove_formats(:time, 'h.nn_ampm')
+      formats.time_formats.should_not include("h o'clock")
+    end
+    
+    it "should not match time after its format is removed" do      
+      validate('2.12am', :time).should be_true
+      formats.remove_formats(:time, 'h.nn_ampm')
+      validate('2.12am', :time).should be_false
+    end
+    
+    it "should raise error if format does not exist" do
+      lambda { formats.remove_formats(:time, "ss:hh:nn") }.should raise_error()
+    end
+    
+    after do
+      formats.time_formats << 'h.nn_ampm'
+      # reload class instead
+    end
+  end
+ 
+  describe "adding formats" do  
+    before do
+      formats.compile_format_expressions
+    end
+    
+    it "should add format to format array" do
+      formats.add_formats(:time, "h o'clock")
+      formats.time_formats.should include("h o'clock")
+    end
+    
+    it "should match new format after its added" do      
+      validate("12 o'clock", :time).should be_false
+      formats.add_formats(:time, "h o'clock")
+      validate("12 o'clock", :time).should be_true
+    end
+    
+    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.should == [0,0,0,23,58,59,0]
+    end
+
+    it "should raise error if format exists" do
+      lambda { formats.add_formats(:time, "hh:nn:ss") }.should raise_error()
+    end
+    
+    it "should raise error if format exists" do
+      lambda { formats.add_formats(:time, "ss:hh:nn", :before => 'nn:hh:ss') }.should raise_error()
+    end
+    
+    after do
+      formats.time_formats.delete("h o'clock")
+      formats.time_formats.delete("ss:hh:nn")
+      # reload class instead
+    end
+  end
+  
+  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.should == [2000, 1, 2,0,0,0,0]
+      formats.remove_us_formats
+      time_array = formats.parse('01/02/2000', :date)
+      time_array.should == [2000, 2, 1,0,0,0,0]
+    end
+    
+    after do
+      # reload class      
+    end
+  end
+ 
+  def validate(time_string, type)
+    valid = false
+    formats.send("#{type}_expressions").each do |(regexp, processor)|
+        valid = true and break if /\A#{regexp}\Z/ =~ time_string
+    end
+    valid
+  end
+ 
+  def generate_regexp(format)
+    # wrap in line start and end anchors to emulate extract values method
+    /\A#{formats.send(:format_expression_generator, format)[0]}\Z/
+  end
+  
+  def generate_regexp_str(format)
+    formats.send(:format_expression_generator, format)[0].inspect
+  end
+  
+  def generate_proc(format)
+    formats.send(:format_expression_generator, format)[1]
+  end
+  
+  def delete_format(type, format)
+    formats.send("#{type}_formats").delete(format)
+  end
+end