validates_timeliness 1.0.0

data/spec/spec_helper.rb

@@ -0,0 +1,54 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+$:.unshift(File.dirname(__FILE__))
+$:.unshift(File.dirname(__FILE__) + '/resources')
+
+ENV['RAILS_ENV'] = 'test'
+
+require 'rubygems'
+require 'spec'
+
+vendored_rails = File.dirname(__FILE__) + '/../../../../vendor/rails'
+
+if vendored = File.exists?(vendored_rails)
+  Dir.glob(vendored_rails + "/**/lib").each { |dir| $:.unshift dir }
+else
+  begin
+   require 'ginger' 
+  rescue LoadError
+  end
+  if ENV['VERSION']
+    gem 'rails', ENV['VERSION']
+  else
+    gem 'rails'
+  end
+end
+
+RAILS_ROOT = File.dirname(__FILE__)
+
+require 'rails/version'
+require 'active_record'
+require 'active_record/version'
+require 'action_controller'
+require 'action_view'
+
+require 'spec/rails'
+require 'time_travel/time_travel'
+
+ActiveRecord::Base.default_timezone = :utc
+RAILS_VER = Rails::VERSION::STRING
+puts "Using #{vendored ? 'vendored' : 'gem'} Rails version #{RAILS_VER} (ActiveRecord version #{ActiveRecord::VERSION::STRING})"
+
+require 'validates_timeliness'
+
+if RAILS_VER >= '2.1'
+  Time.zone_default = ActiveSupport::TimeZone['UTC']
+  ActiveRecord::Base.time_zone_aware_attributes = true
+end
+
+ActiveRecord::Migration.verbose = false
+ActiveRecord::Base.establish_connection({:adapter => 'sqlite3', :database => ':memory:'})
+
+require 'sqlite_patch' if RAILS_VER < '2.1'
+
+require 'schema'
+require 'person'

data/spec/time_travel/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Peter Yandell
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/spec/time_travel/time_extensions.rb

@@ -0,0 +1,33 @@
+require 'time'
+
+module TimeTravel
+  module TimeExtensions
+  
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.class_eval do
+        class << self
+          alias_method :immutable_now, :now
+          alias_method :now, :mutable_now
+        end
+      end
+      base.now = nil
+    end
+  
+    module ClassMethods
+
+      @@now = nil
+
+      def now=(time)
+        time = Time.parse(time) if time.instance_of?(String)
+        @@now = time
+      end
+
+      def mutable_now #:nodoc:
+        @@now || immutable_now
+      end
+    
+    end
+  
+  end
+end

data/spec/time_travel/time_travel.rb

@@ -0,0 +1,12 @@
+require 'time_travel/time_extensions'
+
+Time.send(:include, TimeTravel::TimeExtensions)
+
+def at_time(time)
+  Time.now = time
+  begin
+    yield
+  ensure
+    Time.now = nil
+  end
+end

data/spec/validation_methods_spec.rb

@@ -0,0 +1,61 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe ValidatesTimeliness::ValidationMethods do
+  attr_accessor :person
+
+  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
+    
+    it "should return nil for time string with invalid date part" do
+      parse_method("2000-02-30 12:13:14", :datetime).should be_nil
+    end
+    
+    it "should return nil for time string with invalid time part" do
+      parse_method("2000-02-01 25:13:14", :datetime).should be_nil      
+    end
+    
+    it "should return Time object when passed a Time object" do
+      parse_method(Time.now, :datetime).should be_kind_of(Time)
+    end
+        
+    if RAILS_VER >= '2.1'
+      it "should convert time string into current timezone" do
+        Time.zone = 'Melbourne'
+        time = parse_method("2000-01-01 12:13:14", :datetime)
+        Time.zone.utc_offset.should == 10.hours
+      end
+    end
+
+    it "should return nil for invalid date string" do
+      parse_method("2000-02-30", :date).should be_nil      
+    end
+        
+    def parse_method(*args)
+      ActiveRecord::Base.parse_date_time(*args)
+    end
+  end
+
+  describe "make_time" do
+
+    if RAILS_VER >= '2.1'
+
+      it "should create time using current timezone" do
+        Time.zone = 'Melbourne'
+        time = ActiveRecord::Base.send(:make_time, [2000,1,1,12,0,0])
+        time.zone.should == "EST"
+      end
+
+    else
+
+      it "should create time using default timezone" do
+        time = ActiveRecord::Base.send(:make_time, [2000,1,1,12,0,0])
+        time.zone.should == "UTC"
+      end
+
+    end
+
+  end
+
+end

data/spec/validator_spec.rb

@@ -0,0 +1,438 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe ValidatesTimeliness::Validator do
+  attr_accessor :person, :validator
+
+  before :all do
+    # freezes time using time_travel plugin
+    Time.now = Time.utc(2000, 1, 1, 0, 0, 0)
+  end
+
+  after :all do
+    Time.now = nil
+  end
+
+  before :each do
+    @person = Person.new
+  end
+
+  describe "restriction_value" do
+    it "should return Time object when restriction is Time object" do
+      restriction_value(Time.now, :datetime).should be_kind_of(Time)
+    end
+
+    it "should return Time object when restriction is string" do
+      restriction_value("2007-01-01 12:00", :datetime).should be_kind_of(Time)
+    end
+
+    it "should return Time object when restriction is method and method returns Time object" do
+      person.stub!(:datetime_attr).and_return(Time.now)
+      restriction_value(:datetime_attr, :datetime).should be_kind_of(Time)
+    end
+
+    it "should return Time object when restriction is method and method returns string" do
+      person.stub!(:datetime_attr).and_return("2007-01-01 12:00")
+      restriction_value(:datetime_attr, :datetime).should be_kind_of(Time)
+    end
+
+    it "should return Time object when restriction is proc which returns Time object" do
+      restriction_value(lambda { Time.now }, :datetime).should be_kind_of(Time)
+    end
+
+    it "should return Time object when restriction is proc which returns string" do
+      restriction_value(lambda {"2007-01-01 12:00"}, :datetime).should be_kind_of(Time)
+    end
+
+    def restriction_value(restriction, type)
+      configure_validator(:type => type)
+      validator.send(:restriction_value, restriction, person)
+    end
+  end
+
+  describe "instance with defaults" do
+
+    describe "for datetime type" do
+      before do
+        configure_validator(:type => :datetime)
+      end
+
+      it "should have invalid error when date component is invalid" do
+        validate_with(:birth_date_and_time, "2000-01-32 01:02:03")
+        should_have_error(:birth_date_and_time, :invalid_datetime)
+      end
+
+      it "should have invalid error when time component is invalid" do
+        validate_with(:birth_date_and_time, "2000-01-01 25:02:03")
+        should_have_error(:birth_date_and_time, :invalid_datetime)
+      end
+
+      it "should have blank error when value is nil" do
+        validate_with(:birth_date_and_time, nil)
+        should_have_error(:birth_date_and_time, :blank)
+      end
+
+      it "should have no errors when value is valid" do
+        validate_with(:birth_date_and_time, "2000-01-01 12:00:00")
+        should_have_no_error(:birth_date_and_time, :invalid_datetime)
+      end
+    end
+
+    describe "for date type" do
+      before do
+        configure_validator(:type => :date)
+      end
+
+      it "should have invalid error when value is invalid" do
+        validate_with(:birth_date, "2000-01-32")
+        should_have_error(:birth_date, :invalid_date)
+      end
+
+      it "should have blank error when value is nil" do
+        validate_with(:birth_date, nil)
+        should_have_error(:birth_date, :blank)
+      end
+
+      it "should have no error when value is valid" do
+        validate_with(:birth_date, "2000-01-31")
+        should_have_no_error(:birth_date, :invalid_date)
+      end
+    end
+
+    describe "for time type" do
+      before do
+        configure_validator(:type => :time)
+      end
+
+      it "should have invalid error when value is invalid" do
+        validate_with(:birth_time, "25:00")
+        should_have_error(:birth_time, :invalid_time)
+      end
+
+      it "should have blank error when value is nil" do
+        validate_with(:birth_time, nil)
+        should_have_error(:birth_time, :blank)
+      end
+
+      it "should have no errors when value is valid" do
+        validate_with(:birth_date_and_time, "12:00")
+        should_have_no_error(:birth_time, :invalid_time)
+      end
+    end
+
+  end
+
+  describe "instance with before and after restrictions" do
+
+    describe "for datetime type" do
+      before :each do
+        configure_validator(:before => lambda { Time.now }, :after => lambda { 1.day.ago})
+      end
+
+      it "should have before error when value is past :before restriction" do
+        validate_with(:birth_date_and_time, 1.minute.from_now)
+        should_have_error(:birth_date_and_time, :before)
+      end
+
+      it "should have before error when value is on boundary of :before restriction" do
+        validate_with(:birth_date_and_time, Time.now)
+        should_have_error(:birth_date_and_time, :before)
+      end
+
+      it "should have after error when value is before :after restriction" do
+        validate_with(:birth_date_and_time, 2.days.ago)
+        should_have_error(:birth_date_and_time, :after)
+      end
+
+      it "should have after error when value is on boundary of :after restriction" do
+        validate_with(:birth_date_and_time, 1.day.ago)
+        should_have_error(:birth_date_and_time, :after)
+      end
+    end
+
+    describe "for date type" do
+      before :each do
+        configure_validator(:before => 1.day.from_now, :after => 1.day.ago, :type => :date)
+      end
+
+      it "should have error when value is past :before restriction" do
+        validate_with(:birth_date, 2.days.from_now)
+        should_have_error(:birth_date, :before)
+      end
+
+      it "should have error when value is before :after restriction" do
+        validate_with(:birth_date, 2.days.ago)
+        should_have_error(:birth_date, :after)
+      end
+
+      it "should have no error when value is before :before restriction" do
+        validate_with(:birth_date, Time.now)
+        should_have_no_error(:birth_date, :before)
+      end
+
+      it "should have no error when value is after :after restriction" do
+        validate_with(:birth_date, Time.now)
+        should_have_no_error(:birth_date, :after)
+      end
+    end
+
+    describe "for time type" do
+      before :each do
+        configure_validator(:before => "23:00", :after => "06:00", :type => :time)
+      end
+
+      it "should have error when value is on boundary of :before restriction" do
+        validate_with(:birth_time, "23:00")
+        should_have_error(:birth_time, :before)
+      end
+
+      it "should have error when value is on boundary of :after restriction" do
+        validate_with(:birth_time, "06:00")
+        should_have_error(:birth_time, :after)
+      end
+
+      it "should have error when value is past :before restriction" do
+        validate_with(:birth_time, "23:01")
+        should_have_error(:birth_time, :before)
+      end
+
+      it "should have error when value is before :after restriction" do
+        validate_with(:birth_time, "05:59")
+        should_have_error(:birth_time, :after)
+      end
+
+      it "should not have error when value is before :before restriction" do
+        validate_with(:birth_time, "22:59")
+        should_have_no_error(:birth_time, :before)
+      end
+
+      it "should have error when value is before :after restriction" do
+        validate_with(:birth_time, "06:01")
+        should_have_no_error(:birth_time, :before)
+      end
+    end
+  end
+
+  describe "instance with on_or_before and on_or_after restrictions" do
+
+    describe "for datetime type" do
+      before do
+        configure_validator(:on_or_before => Time.now.at_midnight, :on_or_after => 1.day.ago)
+      end
+
+      it "should have error when value is past :on_or_before restriction" do
+        validate_with(:birth_date_and_time, Time.now.at_midnight + 1)
+        should_have_error(:birth_date_and_time, :on_of_before)
+      end
+
+      it "should be valid when value is equal to :on_or_before restriction" do
+        validate_with(:birth_date_and_time, Time.now.at_midnight)
+        should_have_no_error(:birth_date_and_time, :on_of_before)
+      end
+
+      it "should have error when value is before :on_or_after restriction" do
+        validate_with(:birth_date_and_time, 1.days.ago - 1)
+        should_have_error(:birth_date_and_time, :on_of_after)
+      end
+
+      it "should be valid when value is value equal to :on_or_after restriction" do
+        validate_with(:birth_date_and_time, 1.day.ago)
+        should_have_no_error(:birth_date_and_time, :on_of_after)
+      end
+    end
+
+    describe "for date type" do
+      before :each do
+        configure_validator(:on_or_before => 1.day.from_now, :on_or_after => 1.day.ago, :type => :date)
+      end
+
+      it "should have error when value is past :on_or_before restriction" do
+        validate_with(:birth_date, 2.days.from_now)
+        should_have_error(:birth_date, :on_or_before)
+      end
+
+      it "should have error when value is before :on_or_after restriction" do
+        validate_with(:birth_date, 2.days.ago)
+        should_have_error(:birth_date, :on_or_after)
+      end
+
+      it "should be valid when value is equal to :on_or_before restriction" do
+        validate_with(:birth_date, 1.day.from_now)
+        should_have_no_error(:birth_date, :on_or_before)
+      end
+
+      it "should be valid when value value is equal to :on_or_after restriction" do
+        validate_with(:birth_date, 1.day.ago)
+        should_have_no_error(:birth_date, :on_or_before)
+      end
+    end
+
+    describe "for time type" do
+      before :each do
+        configure_validator(:on_or_before => "23:00", :on_or_after => "06:00", :type => :time)
+      end
+
+      it "should have error when value is past :on_or_before restriction" do
+        validate_with(:birth_time, "23:01")
+        should_have_error(:birth_time, :on_or_before)
+      end
+
+      it "should have error when value is before :on_or_after restriction" do
+        validate_with(:birth_time, "05:59")
+        should_have_error(:birth_time, :on_or_after)
+      end
+
+      it "should be valid when value is on boundary of :on_or_before restriction" do
+        validate_with(:birth_time, "23:00")
+        should_have_no_error(:birth_time, :on_or_before)
+      end
+
+      it "should be valid when value is on boundary of :on_or_after restriction" do
+        validate_with(:birth_time, "06:00")
+        should_have_no_error(:birth_time, :on_or_after)
+      end
+    end
+  end
+
+  describe "instance with mixed value and restriction types" do
+
+    it "should validate datetime attribute with Date restriction" do
+      configure_validator(:type => :datetime, :on_or_before => Date.new(2000,1,1))
+      validate_with(:birth_date_and_time, "2000-01-01 00:00:00")
+      should_have_no_error(:birth_date_and_time, :on_or_before)
+    end
+
+    it "should validate date attribute with DateTime restriction value" do
+      configure_validator(:type => :date, :on_or_before => DateTime.new(2000, 1, 1, 0,0,0))
+      validate_with(:birth_date, "2000-01-01")
+      should_have_no_error(:birth_date, :on_or_before)
+    end
+
+    it "should validate date attribute with Time restriction value" do
+      configure_validator(:type => :date, :on_or_before => Time.utc(2000, 1, 1, 0,0,0))
+      validate_with(:birth_date, "2000-01-01")
+      should_have_no_error(:birth_date, :on_or_before)
+    end
+
+    it "should validate time attribute with DateTime restriction value" do
+      configure_validator(:type => :time, :on_or_before => DateTime.new(2000, 1, 1, 12,0,0))
+      validate_with(:birth_time, "12:00")
+      should_have_no_error(:birth_time, :on_or_before)
+    end
+
+    it "should validate time attribute with Time restriction value" do
+      configure_validator(:type => :time, :on_or_before => Time.utc(2000, 1, 1, 12,0,0))
+      validate_with(:birth_time, "12:00")
+      should_have_no_error(:birth_time, :on_or_before)
+    end
+  end
+
+  describe "restriction errors" do
+    before :each do
+      configure_validator(:type => :date, :before => lambda { raise })
+    end
+
+    it "should be added by default for invalid restriction" do
+      ValidatesTimeliness::Validator.ignore_restriction_errors = false
+      validate_with(:birth_date, Date.today)
+      person.errors.on(:birth_date).should match(/restriction 'before' value was invalid/)
+    end
+
+    it "should not be added when ignore switch is true and restriction is invalid" do
+      ValidatesTimeliness::Validator.ignore_restriction_errors = true
+      person.should be_valid
+    end
+
+    after :all do
+      ValidatesTimeliness::Validator.ignore_restriction_errors = false
+    end
+  end
+
+  describe "restriction value error message" do
+
+    describe "default formats" do
+
+      it "should format datetime value of restriction" do
+        configure_validator(:type => :datetime, :after => 1.day.from_now)
+        validate_with(:birth_date_and_time, Time.now)
+        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
+        configure_validator(:type => :date, :after => 1.day.from_now)
+        validate_with(:birth_date, Time.now)
+        person.errors.on(:birth_date).should match(/after \d{4}-\d{2}-\d{2}\Z/)
+      end
+
+      it "should format time value of restriction" do
+        configure_validator(:type => :time, :after => '12:00')
+        validate_with(:birth_time, '11:59')
+        person.errors.on(:birth_time).should match(/after \d{2}:\d{2}:\d{2}\Z/)
+      end
+    end
+
+    describe "custom formats" do
+
+      before :all do
+        @@formats = ValidatesTimeliness::Validator.error_value_formats
+        ValidatesTimeliness::Validator.error_value_formats = {
+          :time     => '%H:%M %p',
+          :date     => '%d-%m-%Y',
+          :datetime => '%d-%m-%Y %H:%M %p'
+        }
+      end
+
+      it "should format datetime value of restriction" do
+        configure_validator(:type => :datetime, :after => 1.day.from_now)
+        validate_with(:birth_date_and_time, Time.now)
+        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
+        configure_validator(:type => :date, :after => 1.day.from_now)
+        validate_with(:birth_date, Time.now)
+        person.errors.on(:birth_date).should match(/after \d{2}-\d{2}-\d{4}\Z/)
+      end
+
+      it "should format time value of restriction" do
+        configure_validator(:type => :time, :after => '12:00')
+        validate_with(:birth_time, '11:59')
+        person.errors.on(:birth_time).should match(/after \d{2}:\d{2} (AM|PM)\Z/)
+      end
+
+      after :all do
+        ValidatesTimeliness::Validator.error_value_formats = @@formats
+      end
+    end
+
+  end
+
+  def configure_validator(options={})
+    @validator = ValidatesTimeliness::Validator.new(options)
+  end
+
+  def validate_with(attr_name, value)
+    person.send("#{attr_name}=", value)
+    validator.call(person, attr_name)
+  end
+
+  def should_have_error(attr_name, error)
+    message = error_messages[error]
+    person.errors.on(attr_name).should match(/#{message}/)
+  end
+
+  def should_have_no_error(attr_name, error)
+    message = error_messages[error]
+    errors = person.errors.on(attr_name)
+    if errors
+      errors.should_not match(/#{message}/)
+    else
+      errors.should be_nil
+    end
+  end
+
+  def error_messages
+    return @error_messages if defined?(@error_messages)
+    messages = validator.send(:error_messages)
+    @error_messages = messages.inject({}) {|h, (k, v)| h[k] = v.gsub(/ (\%s|\{\{\w*\}\})/, ''); h }
+  end
+end