From 24db8ab7745313b20d8a8a2c72f58bd91f1eaa5e Mon Sep 17 00:00:00 2001
From: Adam Meehan <adam.meehan@gmail.com>
Date: Fri, 25 Jul 2008 19:17:55 +1000
Subject: [PATCH] changed to using accessor for model instance and using
 specific validation method for each type

---
 spec/validations_spec.rb | 315 ++++++++++++++++++++++++---------------
 1 file changed, 195 insertions(+), 120 deletions(-)

diff --git a/spec/validations_spec.rb b/spec/validations_spec.rb
index efe2cfb..2a79e52 100644
--- a/spec/validations_spec.rb
+++ b/spec/validations_spec.rb
@@ -1,6 +1,8 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
 describe ValidatesTimeliness::Validations do
+  attr_accessor :person
+
   before :all do
     # freezes time using time_travel plugin
     Time.now = Time.utc(2000, 1, 1, 0, 0, 0)
@@ -10,7 +12,7 @@ describe ValidatesTimeliness::Validations do
     Time.now = nil
   end
   
-  describe "timeliness_date_time_parse" do
+  describe "parse_date_time" do
     it "should return time object for valid time string" do
       parse_method("2000-01-01 12:13:14", :datetime).should be_kind_of(Time)
     end
@@ -47,9 +49,9 @@ describe ValidatesTimeliness::Validations do
   describe "with no restrictions" do
     before :all do
       class BasicValidation < Person
-        validates_timeliness_of :birth_date_and_time, :allow_blank => true, :type => :datetime
-        validates_timeliness_of :birth_date, :allow_blank => true, :type => :date
-        validates_timeliness_of :birth_time, :allow_blank => true, :type => :time
+        validates_datetime :birth_date_and_time, :allow_blank => true
+        validates_date :birth_date, :allow_blank => true
+        validates_time :birth_time, :allow_blank => true
       end
     end
 
@@ -58,47 +60,47 @@ describe ValidatesTimeliness::Validations do
     end
 
     it "should have error for invalid date component for datetime column" do
-      @person.birth_date_and_time = "2000-01-32 01:02:03"
-      @person.should_not be_valid
-      @person.errors.on(:birth_date_and_time).should == "is not a valid datetime"
+      person.birth_date_and_time = "2000-01-32 01:02:03"
+      person.should_not be_valid
+      person.errors.on(:birth_date_and_time).should == "is not a valid datetime"
     end
 
     it "should have error for invalid time component for datetime column" do
-      @person.birth_date_and_time = "2000-01-01 25:02:03"
-      @person.should_not be_valid 
-      @person.errors.on(:birth_date_and_time).should == "is not a valid datetime"
+      person.birth_date_and_time = "2000-01-01 25:02:03"
+      person.should_not be_valid 
+      person.errors.on(:birth_date_and_time).should == "is not a valid datetime"
     end
 
     it "should have error for invalid date value for date column" do
-      @person.birth_date = "2000-01-32"
-      @person.should_not be_valid
-      @person.errors.on(:birth_date).should == "is not a valid date"
+      person.birth_date = "2000-01-32"
+      person.should_not be_valid
+      person.errors.on(:birth_date).should == "is not a valid date"
     end
 
     it "should have error for invalid time value for time column" do
-      @person.birth_time = "25:00"
-      @person.should_not be_valid
-      @person.errors.on(:birth_time).should == "is not a valid time"
+      person.birth_time = "25:00"
+      person.should_not be_valid
+      person.errors.on(:birth_time).should == "is not a valid time"
     end
 
     it "should be valid with valid values" do
-      @person.birth_date_and_time = "2000-01-01 12:12:12"
-      @person.birth_date = "2000-01-31"
-      @person.should be_valid
+      person.birth_date_and_time = "2000-01-01 12:12:12"
+      person.birth_date = "2000-01-31"
+      person.should be_valid
     end
     
     it "should be valid with values before out of Time range" do
-      @person.birth_date_and_time = "1890-01-01 12:12:12"
-      @person.birth_date = "1890-01-31"
-      @person.birth_time = "23:59:59"
-      @person.should be_valid
+      person.birth_date_and_time = "1890-01-01 12:12:12"
+      person.birth_date = "1890-01-31"
+      person.birth_time = "23:59:59"
+      person.should be_valid
     end
     
-    it "should be valid with nil values when allow_blank si true" do
-      @person.birth_date_and_time = nil
-      @person.birth_date = nil
-      @person.birth_time = nil      
-      @person.should be_valid
+    it "should be valid with nil values when allow_blank is true" do
+      person.birth_date_and_time = nil
+      person.birth_date = nil
+      person.birth_time = nil      
+      person.should be_valid
     end
   end
   
@@ -107,7 +109,7 @@ describe ValidatesTimeliness::Validations do
     describe "with before and after restrictions" do
       before :all do
         class DateTimeBeforeAfter < Person
-          validates_timeliness_of :birth_date_and_time, :type => :datetime,
+          validates_datetime :birth_date_and_time,
             :before => lambda { Time.now }, :after => lambda { 1.day.ago}
         end
       end
@@ -117,34 +119,34 @@ describe ValidatesTimeliness::Validations do
       end
       
       it "should have error when past :before restriction" do
-        @person.birth_date_and_time = 1.minute.from_now
-        @person.should_not be_valid
-        @person.errors.on(:birth_date_and_time).should match(/must be before/)
+        person.birth_date_and_time = 1.minute.from_now
+        person.should_not be_valid
+        person.errors.on(:birth_date_and_time).should match(/must be before/)
       end
 
       it "should have error when before :after restriction" do
-        @person.birth_date_and_time = 2.days.ago
-        @person.should_not be_valid
-        @person.errors.on(:birth_date_and_time).should match(/must be after/)
+        person.birth_date_and_time = 2.days.ago
+        person.should_not be_valid
+        person.errors.on(:birth_date_and_time).should match(/must be after/)
       end
       
       it "should have error when on boundary of :before restriction" do
-        @person.birth_date_and_time = Time.now
-        @person.should_not be_valid
-        @person.errors.on(:birth_date_and_time).should match(/must be before/)
+        person.birth_date_and_time = Time.now
+        person.should_not be_valid
+        person.errors.on(:birth_date_and_time).should match(/must be before/)
       end
 
       it "should have error when on boundary of :after restriction" do
-        @person.birth_date_and_time = 1.day.ago
-        @person.should_not be_valid
-        @person.errors.on(:birth_date_and_time).should match(/must be after/)
+        person.birth_date_and_time = 1.day.ago
+        person.should_not be_valid
+        person.errors.on(:birth_date_and_time).should match(/must be after/)
       end
     end
 
     describe "with on_or_before and on_or_after restrictions" do
       before :all do
         class DateTimeOnOrBeforeAndAfter < Person
-          validates_timeliness_of :birth_date_and_time, :type => :datetime,
+          validates_datetime :birth_date_and_time, :type => :datetime,
             :on_or_before => lambda { Time.now.at_midnight },
             :on_or_after => lambda { 1.day.ago }
         end
@@ -155,25 +157,25 @@ describe ValidatesTimeliness::Validations do
       end
         
       it "should have error when past :on_or_before restriction" do
-        @person.birth_date_and_time = Time.now.at_midnight + 1
-        @person.should_not be_valid
-        @person.errors.on(:birth_date_and_time).should match(/must be on or before/)
+        person.birth_date_and_time = Time.now.at_midnight + 1
+        person.should_not be_valid
+        person.errors.on(:birth_date_and_time).should match(/must be on or before/)
       end
 
       it "should have error when before :on_or_after restriction" do
-        @person.birth_date_and_time = 1.days.ago - 1
-        @person.should_not be_valid
-        @person.errors.on(:birth_date_and_time).should match(/must be on or after/)
+        person.birth_date_and_time = 1.days.ago - 1
+        person.should_not be_valid
+        person.errors.on(:birth_date_and_time).should match(/must be on or after/)
       end
       
       it "should be valid when value equal to :on_or_before restriction" do
-        @person.birth_date_and_time = Time.now.at_midnight
-        @person.should be_valid
+        person.birth_date_and_time = Time.now.at_midnight
+        person.should be_valid
       end
 
       it "should be valid when value equal to :on_or_after restriction" do
-        @person.birth_date_and_time = 1.day.ago
-        @person.should be_valid        
+        person.birth_date_and_time = 1.day.ago
+        person.should be_valid        
       end 
     end
 
@@ -184,7 +186,7 @@ describe ValidatesTimeliness::Validations do
     describe "with before and after restrictions" do
       before :all do
         class DateBeforeAfter < Person
-          validates_timeliness_of :birth_date, :type => :date,
+          validates_date :birth_date,
             :before => 1.day.from_now, 
             :after => 1.day.ago
         end        
@@ -195,22 +197,22 @@ describe ValidatesTimeliness::Validations do
       end
       
       it "should have error when past :before restriction" do
-        @person.birth_date = 2.days.from_now
-        @person.should_not be_valid
-        @person.errors.on(:birth_date).should match(/must be before/)
+        person.birth_date = 2.days.from_now
+        person.should_not be_valid
+        person.errors.on(:birth_date).should match(/must be before/)
       end
 
       it "should have error when before :after restriction" do
-        @person.birth_date = 2.days.ago
-        @person.should_not be_valid
-        @person.errors.on(:birth_date).should match(/must be after/)
+        person.birth_date = 2.days.ago
+        person.should_not be_valid
+        person.errors.on(:birth_date).should match(/must be after/)
       end
     end
 
     describe "with on_or_before and on_or_after restrictions" do
       before :all do
         class DateOnOrBeforeAndAfter < Person
-          validates_timeliness_of :birth_date, :type => :date, 
+          validates_date :birth_date,
             :on_or_before => 1.day.from_now,
             :on_or_after => 1.day.ago
         end
@@ -221,25 +223,25 @@ describe ValidatesTimeliness::Validations do
       end
         
       it "should have error when past :on_or_before restriction" do
-        @person.birth_date = 2.days.from_now
-        @person.should_not be_valid
-        @person.errors.on(:birth_date).should match(/must be on or before/)
+        person.birth_date = 2.days.from_now
+        person.should_not be_valid
+        person.errors.on(:birth_date).should match(/must be on or before/)
       end
 
       it "should have error when before :on_or_after restriction" do
-        @person.birth_date = 2.days.ago
-        @person.should_not be_valid
-        @person.errors.on(:birth_date).should match(/must be on or after/)
+        person.birth_date = 2.days.ago
+        person.should_not be_valid
+        person.errors.on(:birth_date).should match(/must be on or after/)
       end
       
       it "should be valid when value equal to :on_or_before restriction" do
-        @person.birth_date = 1.day.from_now
-        @person.should be_valid
+        person.birth_date = 1.day.from_now
+        person.should be_valid
       end
 
       it "should be valid when value equal to :on_or_after restriction" do
-        @person.birth_date = 1.day.ago
-        @person.should be_valid        
+        person.birth_date = 1.day.ago
+        person.should be_valid        
       end      
     end 
   end
@@ -249,7 +251,7 @@ describe ValidatesTimeliness::Validations do
     describe "with before and after restrictions" do
       before :all do
         class TimeBeforeAfter < Person
-          validates_timeliness_of :birth_time, :type => :time,
+          validates_time :birth_time,
             :before => "23:00", 
             :after => "06:00"
         end        
@@ -260,44 +262,44 @@ describe ValidatesTimeliness::Validations do
       end
       
       it "should have error when on boundary of :before restriction" do
-        @person.birth_time = "23:00"
-        @person.should_not be_valid
-        @person.errors.on(:birth_time).should match(/must be before/)
+        person.birth_time = "23:00"
+        person.should_not be_valid
+        person.errors.on(:birth_time).should match(/must be before/)
       end
 
       it "should have error when on boundary of :after restriction" do
-        @person.birth_time = "06:00am"
-        @person.should_not be_valid
-        @person.errors.on(:birth_time).should match(/must be after/)
+        person.birth_time = "06:00am"
+        person.should_not be_valid
+        person.errors.on(:birth_time).should match(/must be after/)
       end
       
       it "should have error when past :before restriction" do
-        @person.birth_time = "23:01"
-        @person.should_not be_valid
-        @person.errors.on(:birth_time).should match(/must be before/)
+        person.birth_time = "23:01"
+        person.should_not be_valid
+        person.errors.on(:birth_time).should match(/must be before/)
       end
 
       it "should have error when before :after restriction" do
-        @person.birth_time = "05:59"
-        @person.should_not be_valid
-        @person.errors.on(:birth_time).should match(/must be after/)
+        person.birth_time = "05:59"
+        person.should_not be_valid
+        person.errors.on(:birth_time).should match(/must be after/)
       end
       
       it "should not have error when before :before restriction" do
-        @person.birth_time = "22:59"
-        @person.should be_valid
+        person.birth_time = "22:59"
+        person.should be_valid
       end
 
       it "should have error when before :after restriction" do
-        @person.birth_time = "06:01"
-        @person.should be_valid
+        person.birth_time = "06:01"
+        person.should be_valid
       end
     end
 
     describe "with on_or_before and on_or_after restrictions" do
       before :all do
         class TimeOnOrBeforeAndAfter < Person
-          validates_timeliness_of :birth_time, :type => :time,
+          validates_time :birth_time,
             :on_or_before => "23:00",
             :on_or_after => "06:00"
         end
@@ -308,25 +310,25 @@ describe ValidatesTimeliness::Validations do
       end
         
       it "should have error when past :on_or_before restriction" do
-        @person.birth_time = "23:01"
-        @person.should_not be_valid
-        @person.errors.on(:birth_time).should match(/must be on or before/)
+        person.birth_time = "23:01"
+        person.should_not be_valid
+        person.errors.on(:birth_time).should match(/must be on or before/)
       end
 
       it "should have error when before :on_or_after restriction" do
-        @person.birth_time = "05:59"
-        @person.should_not be_valid
-        @person.errors.on(:birth_time).should match(/must be on or after/)
+        person.birth_time = "05:59"
+        person.should_not be_valid
+        person.errors.on(:birth_time).should match(/must be on or after/)
       end
       
       it "should be valid when on boundary of :on_or_before restriction" do
-        @person.birth_time = "23:00"
-        @person.should be_valid
+        person.birth_time = "23:00"
+        person.should be_valid
       end
 
       it "should be valid when on boundary of :on_or_after restriction" do
-        @person.birth_time = "06:00"
-        @person.should be_valid        
+        person.birth_time = "06:00"
+        person.should be_valid        
       end      
     end 
   end
@@ -335,12 +337,12 @@ describe ValidatesTimeliness::Validations do
     before :all do
       
       class MixedBeforeAndAfter < Person
-        validates_timeliness_of :birth_date_and_time, 
-                                  :before => Date.new(2000,1,2), 
-                                  :after => lambda { "2000-01-01" }
-        validates_timeliness_of :birth_date, :type => :date, 
-                                  :on_or_before => lambda { "2000-01-01" }, 
-                                  :on_or_after => :birth_date_and_time
+        validates_datetime :birth_date_and_time, 
+                            :before => Date.new(2000,1,2), 
+                            :after => lambda { "2000-01-01" }
+        validates_date :birth_date,
+                            :on_or_before => lambda { "2000-01-01" }, 
+                            :on_or_after => :birth_date_and_time
       end
     end
     
@@ -349,29 +351,29 @@ describe ValidatesTimeliness::Validations do
     end
     
     it "should correctly validate time attribute with Date restriction" do
-      @person.birth_date_and_time = "2000-01-03 00:00:00"
-      @person.should_not be_valid
-      @person.errors.on(:birth_date_and_time).should match(/must be before/)
+      person.birth_date_and_time = "2000-01-03 00:00:00"
+      person.should_not be_valid
+      person.errors.on(:birth_date_and_time).should match(/must be before/)
     end
     
     it "should correctly validate with proc restriction" do
-      @person.birth_date_and_time = "2000-01-01 00:00:00"
-      @person.should_not be_valid
-      @person.errors.on(:birth_date_and_time).should match(/must be after/)
+      person.birth_date_and_time = "2000-01-01 00:00:00"
+      person.should_not be_valid
+      person.errors.on(:birth_date_and_time).should match(/must be after/)
     end
 
     it "should correctly validate date attribute with DateTime restriction" do
-      @person.birth_date = "2000-01-03"
-      @person.birth_date_and_time = "1890-01-01 00:00:00"
-      @person.should_not be_valid
-      @person.errors.on(:birth_date).should match(/must be on or before/)
+      person.birth_date = "2000-01-03"
+      person.birth_date_and_time = "1890-01-01 00:00:00"
+      person.should_not be_valid
+      person.errors.on(:birth_date).should match(/must be on or before/)
     end
 
     it "should correctly validate date attribute with symbol restriction" do
-      @person.birth_date = "2000-01-01"
-      @person.birth_date_and_time = "2000-01-02 12:00:00"
-      @person.should_not be_valid
-      @person.errors.on(:birth_date).should match(/must be on or after/)
+      person.birth_date = "2000-01-01"
+      person.birth_date_and_time = "2000-01-02 12:00:00"
+      person.should_not be_valid
+      person.errors.on(:birth_date).should match(/must be on or after/)
     end
 
   end
@@ -389,8 +391,81 @@ describe ValidatesTimeliness::Validations do
     end
     
     it "should have no errors when restriction is invalid" do
-      @person.birth_date = '2000-01-01'
-      @person.should be_valid
+      person.birth_date = '2000-01-01'
+      person.should be_valid
     end
   end
+  
+  describe "restriction value error message" do
+    describe "default formats" do
+      before :all do
+        class DefaultFormats < Person
+          validates_datetime :birth_date_and_time, :allow_blank => true, :after => 1.day.from_now
+          validates_date :birth_date, :allow_blank => true, :after => 1.day.from_now
+          validates_time :birth_time, :allow_blank => true, :after => '23:59:59'
+        end
+      end
+
+      before :each do
+        @person = DefaultFormats.new
+      end
+      
+      it "should format datetime value of restriction" do
+        person.birth_date_and_time = Time.now
+        person.save
+        person.errors.on(:birth_date_and_time).should match(/after \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\Z/)
+      end
+      
+      it "should format date value of restriction" do
+        person.birth_date = Time.now
+        person.save
+        person.errors.on(:birth_date).should match(/after \d{4}-\d{2}-\d{2}\Z/)
+      end
+      
+      it "should format time value of restriction" do
+        person.birth_time = '12:00:00'
+        person.save
+        person.errors.on(:birth_time).should match(/after \d{2}:\d{2}:\d{2}\Z/)
+      end
+    end
+    
+    describe "custom formats" do
+      before :all do
+        class CustomFormats < Person
+          validates_datetime :birth_date_and_time, :allow_blank => true, :after => 1.day.from_now
+          validates_date :birth_date, :allow_blank => true, :after => 1.day.from_now
+          validates_time :birth_time, :allow_blank => true, :after => '23:59:59'
+        end
+
+        ActiveRecord::Errors.date_time_error_value_formats = {
+          :time => '%H:%M %p',
+          :date => '%d-%m-%Y',
+          :datetime => '%d-%m-%Y %H:%M %p'
+        }
+      end
+
+      before :each do
+        @person = CustomFormats.new
+      end
+      
+      it "should format datetime value of restriction" do
+        person.birth_date_and_time = Time.now
+        person.save
+        person.errors.on(:birth_date_and_time).should match(/after \d{2}-\d{2}-\d{4} \d{2}:\d{2} (AM|PM)\Z/)
+      end
+      
+      it "should format date value of restriction" do
+        person.birth_date = Time.now
+        person.save
+        person.errors.on(:birth_date).should match(/after \d{2}-\d{2}-\d{4}\Z/)
+      end
+      
+      it "should format time value of restriction" do
+        person.birth_time = '12:00:00'
+        person.save
+        person.errors.on(:birth_time).should match(/after \d{2}:\d{2} (AM|PM)\Z/)
+      end
+    end
+    
+  end
 end