sp-validates_timeliness 3.1.2

data/spec/support/tag_matcher.rb

@@ -0,0 +1,35 @@
+require 'nokogiri'
+
+module TagMatcher
+  extend RSpec::Matchers::DSL
+
+  matcher :have_tag do |selector|
+    match do |subject|
+      matches = doc(subject).search(selector)
+
+      if @inner_text
+        matches = matches.select { |element| element.inner_text == @inner_text }
+      end
+
+      matches.any?
+    end
+
+    chain :with_inner_text do |inner_text|
+      @inner_text = inner_text
+    end
+
+    private
+
+    def body(subject)
+      if subject.respond_to?(:body)
+        subject.body
+      else
+        subject.to_s
+      end
+    end
+
+    def doc(subject)
+      @doc ||= Nokogiri::HTML(body(subject))
+    end
+  end
+end

data/spec/support/test_model.rb

@@ -0,0 +1,59 @@
+module TestModel
+  extend ActiveSupport::Concern
+  extend ActiveModel::Translation
+  include ActiveModel::Validations
+  include ActiveModel::AttributeMethods
+
+  included do
+    attribute_method_suffix "="
+    cattr_accessor :model_attributes
+  end
+
+  module ClassMethods
+    def attribute(name, type)
+      self.model_attributes ||= {}
+      self.model_attributes[name] = type
+    end
+
+    def define_method_attribute=(attr_name)
+      generated_attribute_methods.module_eval("def #{attr_name}=(new_value); @attributes['#{attr_name}']=self.class.type_cast('#{attr_name}', new_value); end", __FILE__, __LINE__)
+    end
+
+    def define_method_attribute(attr_name)
+      generated_attribute_methods.module_eval("def #{attr_name}; @attributes['#{attr_name}']; end", __FILE__, __LINE__)
+    end
+
+    def type_cast(attr_name, value)
+      return value unless value.is_a?(String)
+      value.send("to_#{model_attributes[attr_name.to_sym]}") rescue nil
+    end
+  end
+
+  def initialize(attributes = nil)
+    @attributes = self.class.model_attributes.keys.inject({}) do |hash, column|
+      hash[column.to_s] = nil
+      hash
+    end
+    self.attributes = attributes unless attributes.nil?
+  end
+
+  def attributes
+    @attributes
+  end
+
+  def attributes=(new_attributes={})
+    new_attributes.each do |key, value|
+      send "#{key}=", value
+    end
+  end
+
+  def method_missing(method_id, *args, &block)
+    if match_attribute_method?(method_id.to_s)
+      self.class.define_attribute_methods self.class.model_attributes.keys
+      send(method_id, *args, &block)
+    else
+      super
+    end
+  end
+end
+

data/spec/validates_timeliness/attribute_methods_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe ValidatesTimeliness::AttributeMethods do
+  it 'should define _timeliness_raw_value_for instance method' do
+    expect(PersonWithShim.new).to respond_to(:_timeliness_raw_value_for)
+  end
+
+  describe ".timeliness_validated_attributes" do
+    it 'should return attributes validated with plugin validator' do
+      PersonWithShim.timeliness_validated_attributes = []
+      PersonWithShim.validates_date :birth_date
+      PersonWithShim.validates_time :birth_time
+      PersonWithShim.validates_datetime :birth_datetime
+
+      expect(PersonWithShim.timeliness_validated_attributes).to eq([ :birth_date, :birth_time, :birth_datetime ])
+    end
+  end
+
+  context "attribute write method" do
+    class PersonWithCache
+      include TestModel
+      include TestModelShim
+      attribute :birth_date, :date
+      attribute :birth_time, :time
+      attribute :birth_datetime, :datetime
+      validates_date :birth_date
+      validates_time :birth_time
+      validates_datetime :birth_datetime
+    end
+
+    it 'should cache attribute raw value' do
+      r = PersonWithCache.new
+      r.birth_datetime = date_string = '2010-01-01'
+      expect(r._timeliness_raw_value_for('birth_datetime')).to eq(date_string)
+    end
+
+    it 'should not overwrite user defined methods' do
+      e = Employee.new
+      e.birth_date = '2010-01-01'
+      expect(e.redefined_birth_date_called).to be_truthy
+    end
+
+    it 'should be undefined if model class has dynamic attribute methods reset' do
+      # Force method definitions
+      PersonWithShim.validates_date :birth_date
+      r = PersonWithShim.new
+      r.birth_date = Time.now
+
+      write_method = RUBY_VERSION < '1.9' ? 'birth_date=' : :birth_date=
+
+      expect(PersonWithShim.send(:generated_timeliness_methods).instance_methods).to include(write_method)
+
+      PersonWithShim.undefine_attribute_methods
+
+      expect(PersonWithShim.send(:generated_timeliness_methods).instance_methods).not_to include(write_method)
+    end
+
+    context "with plugin parser" do
+      with_config(:use_plugin_parser, true)
+
+      class PersonWithParser
+        include TestModel
+        include TestModelShim
+        attribute :birth_date, :date
+        attribute :birth_time, :time
+        attribute :birth_datetime, :datetime
+        validates_date :birth_date
+        validates_time :birth_time
+        validates_datetime :birth_datetime
+      end
+
+      it 'should parse a string value' do
+        expect(Timeliness::Parser).to receive(:parse)
+        r = PersonWithParser.new
+        r.birth_date = '2010-01-01'
+      end
+
+    end
+  end
+
+  context "before_type_cast method" do
+    it 'should not be defined if ORM does not support it' do
+      expect(PersonWithShim.new).not_to respond_to(:birth_datetime_before_type_cast)
+    end
+  end
+end

data/spec/validates_timeliness/conversion_spec.rb

@@ -0,0 +1,234 @@
+require 'spec_helper'
+
+describe ValidatesTimeliness::Conversion do
+  include ValidatesTimeliness::Conversion
+
+  let(:options) { Hash.new }
+
+  before do
+    Timecop.freeze(Time.mktime(2010, 1, 1, 0, 0, 0))
+  end
+
+  describe "#type_cast_value" do
+    describe "for date type" do
+      it "should return same value for date value" do
+        expect(type_cast_value(Date.new(2010, 1, 1), :date)).to eq(Date.new(2010, 1, 1))
+      end
+
+      it "should return date part of time value" do
+        expect(type_cast_value(Time.mktime(2010, 1, 1, 0, 0, 0), :date)).to eq(Date.new(2010, 1, 1))
+      end
+
+      it "should return date part of datetime value" do
+        expect(type_cast_value(DateTime.new(2010, 1, 1, 0, 0, 0), :date)).to eq(Date.new(2010, 1, 1))
+      end
+
+      it 'should return nil for invalid value types' do
+        expect(type_cast_value(12, :date)).to eq(nil)
+      end
+    end
+
+    describe "for time type" do
+      it "should return same value for time value matching dummy date part" do
+        expect(type_cast_value(Time.utc(2000, 1, 1, 0, 0, 0), :time)).to eq(Time.utc(2000, 1, 1, 0, 0, 0))
+      end
+
+      it "should return dummy time value with same time part for time value with different date" do
+        expect(type_cast_value(Time.utc(2010, 1, 1, 0, 0, 0), :time)).to eq(Time.utc(2000, 1, 1, 0, 0, 0))
+      end
+
+      it "should return dummy time only for date value" do
+        expect(type_cast_value(Date.new(2010, 1, 1), :time)).to eq(Time.utc(2000, 1, 1, 0, 0, 0))
+      end
+
+      it "should return dummy date with time part for datetime value" do
+        expect(type_cast_value(DateTime.civil_from_format(:utc, 2010, 1, 1, 12, 34, 56), :time)).to eq(Time.utc(2000, 1, 1, 12, 34, 56))
+      end
+
+      it 'should return nil for invalid value types' do
+        expect(type_cast_value(12, :time)).to eq(nil)
+      end
+    end
+
+    describe "for datetime type" do
+      it "should return Date as Time value" do
+        expect(type_cast_value(Date.new(2010, 1, 1), :datetime)).to eq(Time.local_time(2010, 1, 1, 0, 0, 0))
+      end
+
+      it "should return same Time value" do
+        value = Time.utc(2010, 1, 1, 12, 34, 56)
+        expect(type_cast_value(Time.utc(2010, 1, 1, 12, 34, 56), :datetime)).to eq(value)
+      end
+
+      it "should return as Time with same component values" do
+        expect(type_cast_value(DateTime.civil_from_format(:utc, 2010, 1, 1, 12, 34, 56), :datetime)).to eq(Time.utc(2010, 1, 1, 12, 34, 56))
+      end
+
+      it "should return same Time in correct zone if timezone aware" do
+        @timezone_aware = true
+        value = Time.utc(2010, 1, 1, 12, 34, 56)
+        result = type_cast_value(value, :datetime)
+        expect(result).to eq(Time.zone.local(2010, 1, 1, 23, 34, 56))
+        expect(result.zone).to eq('AEDT') # 'Australia/Melbourne'
+      end
+
+      it 'should return nil for invalid value types' do
+        expect(type_cast_value(12, :datetime)).to eq(nil)
+      end
+    end
+
+    describe "ignore_usec option" do
+      let(:options) { {:ignore_usec => true} }
+
+      it "should ignore usec on time values when evaluated" do
+        value = Time.utc(2010, 1, 1, 12, 34, 56, 10000)
+        expect(type_cast_value(value, :datetime)).to eq(Time.utc(2010, 1, 1, 12, 34, 56))
+      end
+
+      it "should ignore usec and return time in correct zone if timezone aware" do
+        @timezone_aware = true
+        value = Time.utc(2010, 1, 1, 12, 34, 56, 10000)
+        result = type_cast_value(value, :datetime)
+        expect(result).to eq(Time.zone.local(2010, 1, 1, 23, 34, 56))
+        expect(result.zone).to eq('AEDT') # 'Australia/Melbourne'
+      end
+    end
+  end
+
+  describe "#dummy_time" do
+    it 'should return Time with dummy date values but same time components' do
+      expect(dummy_time(Time.utc(2010, 11, 22, 12, 34, 56))).to eq(Time.utc(2000, 1, 1, 12, 34, 56))
+    end
+
+    it 'should return same value for Time which already has dummy date values' do
+      expect(dummy_time(Time.utc(2000, 1, 1, 12, 34, 56))).to eq(Time.utc(2000, 1, 1, 12, 34, 56))
+    end
+
+    it 'should return time component values shifted to current zone if timezone aware' do
+      @timezone_aware = true
+      expect(dummy_time(Time.utc(2000, 1, 1, 12, 34, 56))).to eq(Time.zone.local(2000, 1, 1, 23, 34, 56))
+    end
+
+    it 'should return base dummy time value for Date value' do
+      expect(dummy_time(Date.new(2010, 11, 22))).to eq(Time.utc(2000, 1, 1, 0, 0, 0))
+    end
+
+    describe "with custom dummy date" do
+      it 'should return dummy time with custom dummy date' do
+        with_config(:dummy_date_for_time_type, [2010, 1, 1] ) do
+          expect(dummy_time(Time.utc(1999, 11, 22, 12, 34, 56))).to eq(Time.utc(2010, 1, 1, 12, 34, 56))
+        end
+      end
+    end
+  end
+
+  describe "#evaluate_option_value" do
+    let(:person) { Person.new }
+
+    it 'should return Date object as is' do
+      value = Date.new(2010,1,1)
+      expect(evaluate_option_value(value, person)).to eq(value)
+    end
+
+    it 'should return Time object as is' do
+      value = Time.mktime(2010,1,1)
+      expect(evaluate_option_value(value, person)).to eq(value)
+    end
+
+    it 'should return DateTime object as is' do
+      value = DateTime.new(2010,1,1,0,0,0)
+      expect(evaluate_option_value(value, person)).to eq(value)
+    end
+
+    it 'should return Time value returned from proc with 0 arity' do
+      value = Time.mktime(2010,1,1)
+      expect(evaluate_option_value(lambda { value }, person)).to eq(value)
+    end
+
+    it 'should return Time value returned by record attribute call in proc arity of 1' do
+      value = Time.mktime(2010,1,1)
+      person.birth_time = value
+      expect(evaluate_option_value(lambda {|r| r.birth_time }, person)).to eq(value)
+    end
+
+    it 'should return Time value for attribute method symbol which returns Time' do
+      value = Time.mktime(2010,1,1)
+      person.birth_time = value
+      expect(evaluate_option_value(:birth_time, person)).to eq(value)
+    end
+
+    it 'should return Time value is default zone from string time value' do
+      value = '2010-01-01 12:00:00'
+      expect(evaluate_option_value(value, person)).to eq(Time.utc(2010,1,1,12,0,0))
+    end
+
+    it 'should return Time value is current zone from string time value if timezone aware' do
+      @timezone_aware = true
+      value = '2010-01-01 12:00:00'
+      expect(evaluate_option_value(value, person)).to eq(Time.zone.local(2010,1,1,12,0,0))
+    end
+
+    it 'should return Time value in default zone from proc which returns string time' do
+      value = '2010-01-01 12:00:00'
+      expect(evaluate_option_value(lambda { value }, person)).to eq(Time.utc(2010,1,1,12,0,0))
+    end
+
+    it 'should return Time value for attribute method symbol which returns string time value' do
+      value = '2010-01-01 12:00:00'
+      person.birth_time = value
+      expect(evaluate_option_value(:birth_time, person)).to eq(Time.utc(2010,1,1,12,0,0))
+    end
+
+    context "restriction shorthand" do
+      before do
+        Timecop.freeze(Time.mktime(2010, 1, 1, 0, 0, 0))
+      end
+
+      it 'should evaluate :now as current time' do
+        expect(evaluate_option_value(:now, person)).to eq(Time.now)
+      end
+
+      it 'should evaluate :today as current time' do
+        expect(evaluate_option_value(:today, person)).to eq(Date.today)
+      end
+
+      it 'should not use shorthand if symbol if is record method' do
+        time = 1.day.from_now
+        allow(person).to receive(:now).and_return(time)
+        expect(evaluate_option_value(:now, person)).to eq(time)
+      end
+    end
+  end
+
+  describe "#parse" do
+    context "use_plugin_parser setting is true" do
+      with_config(:use_plugin_parser, true)
+
+      it 'should use timeliness' do
+        expect(Timeliness::Parser).to receive(:parse)
+        parse('2000-01-01')
+      end
+    end
+
+    context "use_plugin_parser setting is false" do
+      with_config(:use_plugin_parser, false)
+
+      it 'should use Time.zone.parse attribute is timezone aware' do
+        @timezone_aware = true
+        expect(Time.zone).to receive(:parse)
+        parse('2000-01-01')
+      end
+
+      it 'should use value#to_time if use_plugin_parser setting is false and attribute is not timezone aware' do
+        @timezone_aware = false
+        value = '2000-01-01'
+        expect(value).to receive(:to_time)
+        parse(value)
+      end
+    end
+
+    it 'should return nil if value is nil' do
+      expect(parse(nil)).to be_nil
+    end
+  end
+end

data/spec/validates_timeliness/extensions/date_time_select_spec.rb

@@ -0,0 +1,163 @@
+require 'spec_helper'
+
+describe ValidatesTimeliness::Extensions::DateTimeSelect do
+  include ActionView::Helpers::DateHelper
+  attr_reader :person, :params
+
+  with_config(:use_plugin_parser, true)
+
+  before do
+    @person = Person.new
+    @params = {}
+  end
+
+  describe "datetime_select" do
+    it "should use param values when attribute is nil" do
+      @params["person"] = {
+        "birth_datetime(1i)" => '2009',
+        "birth_datetime(2i)" => '2',
+        "birth_datetime(3i)" => '29',
+        "birth_datetime(4i)" => '12',
+        "birth_datetime(5i)" => '13',
+        "birth_datetime(6i)" => '14',
+      }
+      person.birth_datetime = nil
+      @output = datetime_select(:person, :birth_datetime, :include_blank => true, :include_seconds => true)
+      should_have_datetime_selected(:birth_datetime, :year => 2009, :month => 'February', :day => 29, :hour => 12, :min => 13, :sec => 14)
+    end
+
+    it "should override object values and use params if present" do
+      @params["person"] = {
+        "birth_datetime(1i)" => '2009',
+        "birth_datetime(2i)" => '2',
+        "birth_datetime(3i)" => '29',
+        "birth_datetime(4i)" => '12',
+        "birth_datetime(5i)" => '13',
+        "birth_datetime(6i)" => '14',
+      }
+      person.birth_datetime = "2010-01-01 15:16:17"
+      @output = datetime_select(:person, :birth_datetime, :include_blank => true, :include_seconds => true)
+      should_have_datetime_selected(:birth_datetime, :year => 2009, :month => 'February', :day => 29, :hour => 12, :min => 13, :sec => 14)
+    end
+
+    it "should use attribute values from object if no params" do
+      person.birth_datetime = "2009-01-02 12:13:14"
+      @output = datetime_select(:person, :birth_datetime, :include_blank => true, :include_seconds => true)
+      should_have_datetime_selected(:birth_datetime, :year => 2009, :month => 'January', :day => 2, :hour => 12, :min => 13, :sec => 14)
+    end
+
+    it "should use attribute values if params does not contain attribute params" do
+      person.birth_datetime = "2009-01-02 12:13:14"
+      @params["person"] = { }
+      @output = datetime_select(:person, :birth_datetime, :include_blank => true, :include_seconds => true)
+      should_have_datetime_selected(:birth_datetime, :year => 2009, :month => 'January', :day => 2, :hour => 12, :min => 13, :sec => 14)
+    end
+
+    it "should not select values when attribute value is nil and has no param values" do
+      person.birth_datetime = nil
+      @output = datetime_select(:person, :birth_datetime, :include_blank => true, :include_seconds => true)
+      should_not_have_datetime_selected(:birth_datetime, :year, :month, :day, :hour, :min, :sec)
+    end
+  end
+
+  describe "date_select" do
+    it "should use param values when attribute is nil" do
+      @params["person"] = {
+        "birth_date(1i)" => '2009',
+        "birth_date(2i)" => '2',
+        "birth_date(3i)" => '29',
+      }
+      person.birth_date = nil
+      @output = date_select(:person, :birth_date, :include_blank => true)
+      should_have_datetime_selected(:birth_date, :year => 2009, :month => 'February', :day => 29)
+    end
+
+    it "should override object values and use params if present" do
+      @params["person"] = {
+        "birth_date(1i)" => '2009',
+        "birth_date(2i)" => '2',
+        "birth_date(3i)" => '29',
+      }
+      person.birth_date = "2009-03-01"
+      @output = date_select(:person, :birth_date, :include_blank => true)
+      should_have_datetime_selected(:birth_date, :year => 2009, :month => 'February', :day => 29)
+    end
+
+    it "should select attribute values from object if no params" do
+      person.birth_date = "2009-01-02"
+      @output = date_select(:person, :birth_date, :include_blank => true)
+      should_have_datetime_selected(:birth_date, :year => 2009, :month => 'January', :day => 2)
+    end
+
+    it "should select attribute values if params does not contain attribute params" do
+      person.birth_date = "2009-01-02"
+      @params["person"] = { }
+      @output = date_select(:person, :birth_date, :include_blank => true)
+      should_have_datetime_selected(:birth_date, :year => 2009, :month => 'January', :day => 2)
+    end
+
+    it "should not select values when attribute value is nil and has no param values" do
+      person.birth_date = nil
+      @output = date_select(:person, :birth_date, :include_blank => true)
+      should_not_have_datetime_selected(:birth_time, :year, :month, :day)
+    end
+
+    it "should allow the day part to be discarded" do
+      @params["person"] = {
+        "birth_date(1i)" => '2009',
+        "birth_date(2i)" => '2',
+      }
+
+      @output = date_select(:person, :birth_date, :include_blank => true, :discard_day => true)
+      should_have_datetime_selected(:birth_date, :year => 2009, :month => 'February')
+      should_not_have_datetime_selected(:birth_time, :day)
+      expect(@output).to have_tag("input[id=person_birth_date_3i][type=hidden][value='1']")
+    end
+  end
+
+  describe "time_select" do
+    before do
+      Timecop.freeze Time.mktime(2009,1,1)
+    end
+
+    it "should use param values when attribute is nil" do
+      @params["person"] = {
+        "birth_time(1i)" => '2000',
+        "birth_time(2i)" => '1',
+        "birth_time(3i)" => '1',
+        "birth_time(4i)" => '12',
+        "birth_time(5i)" => '13',
+        "birth_time(6i)" => '14',
+      }
+      person.birth_time = nil
+      @output = time_select(:person, :birth_time, :include_blank => true, :include_seconds => true)
+      should_have_datetime_selected(:birth_time, :hour => 12, :min => 13, :sec => 14)
+    end
+
+    it "should select attribute values from object if no params" do
+      person.birth_time = "2000-01-01 12:13:14"
+      @output = time_select(:person, :birth_time, :include_blank => true, :include_seconds => true)
+      should_have_datetime_selected(:birth_time, :hour => 12, :min => 13, :sec => 14)
+    end
+
+    it "should not select values when attribute value is nil and has no param values" do
+      person.birth_time = nil
+      @output = time_select(:person, :birth_time, :include_blank => true, :include_seconds => true)
+      should_not_have_datetime_selected(:birth_time, :hour, :min, :sec)
+    end
+  end
+
+  def should_have_datetime_selected(field, datetime_hash)
+    datetime_hash.each do |key, value|
+      index = {:year => 1, :month => 2, :day => 3, :hour => 4, :min => 5, :sec => 6}[key]
+      expect(@output).to have_tag("select[id=person_#{field}_#{index}i] option[selected=selected]").with_inner_text(value.to_s)
+    end
+  end
+
+  def should_not_have_datetime_selected(field, *attributes)
+    attributes.each do |attribute|
+      index = {:year => 1, :month => 2, :day => 3, :hour => 4, :min => 5, :sec => 6}[attribute]
+      expect(@output).not_to have_tag("select[id=person_#{attribute}_#{index}i] option[selected=selected]")
+    end
+  end
+end