sp-validates_timeliness 3.1.2

data/spec/validates_timeliness/extensions/multiparameter_handler_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe ValidatesTimeliness::Extensions::MultiparameterHandler do
+
+  context "time column" do
+    it 'should assign a string value for invalid date portion' do
+      employee = record_with_multiparameter_attribute(:birth_datetime, [2000, 2, 31, 12, 0, 0])
+      expect(employee.birth_datetime_before_type_cast).to eq '2000-02-31 12:00:00'
+    end
+     
+    it 'should assign a Time value for valid datetimes' do
+      employee = record_with_multiparameter_attribute(:birth_datetime, [2000, 2, 28, 12, 0, 0])
+      expect(employee.birth_datetime_before_type_cast).to eq Time.zone.local(2000, 2, 28, 12, 0, 0)
+    end
+
+    it 'should assign a string value for incomplete time' do
+      employee = record_with_multiparameter_attribute(:birth_datetime, [2000, nil, nil])
+      expect(employee.birth_datetime_before_type_cast).to eq '2000-00-00'
+    end
+  end
+
+  context "date column" do
+    it 'should assign a string value for invalid date' do
+      employee = record_with_multiparameter_attribute(:birth_date, [2000, 2, 31])
+      expect(employee.birth_date_before_type_cast).to eq '2000-02-31'
+    end
+
+    it 'should assign a Date value for valid date' do
+      employee = record_with_multiparameter_attribute(:birth_date, [2000, 2, 28])
+      expect(employee.birth_date_before_type_cast).to eq Date.new(2000, 2, 28)
+    end
+
+    it 'should assign a string value for incomplete date' do
+      employee = record_with_multiparameter_attribute(:birth_date, [2000, nil, nil])
+      expect(employee.birth_date_before_type_cast).to eq '2000-00-00'
+    end
+  end
+
+  def record_with_multiparameter_attribute(name, values)
+    hash = {}
+    values.each_with_index {|value, index| hash["#{name}(#{index+1}i)"] = value.to_s }
+    Employee.new(hash)
+  end
+end

data/spec/validates_timeliness/helper_methods_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe ValidatesTimeliness, 'HelperMethods' do
+  let(:record) { Person.new }
+  
+  it 'should define class validation methods' do
+    expect(Person).to respond_to(:validates_date)
+    expect(Person).to respond_to(:validates_time)
+    expect(Person).to respond_to(:validates_datetime)
+  end
+
+  it 'should define instance validation methods' do
+    expect(record).to respond_to(:validates_date)
+    expect(record).to respond_to(:validates_time)
+    expect(record).to respond_to(:validates_datetime)
+  end
+
+  it 'should validate instance using class validation defined' do
+    Person.validates_date :birth_date
+    record.valid?
+
+    expect(record.errors[:birth_date]).not_to be_empty
+  end
+
+  it 'should validate instance using instance valiation method' do
+    record.validates_date :birth_date
+
+    expect(record.errors[:birth_date]).not_to be_empty
+  end
+end

data/spec/validates_timeliness/orm/active_record_spec.rb

@@ -0,0 +1,244 @@
+require 'spec_helper'
+
+describe ValidatesTimeliness, 'ActiveRecord' do
+
+  context "validation methods" do
+    let(:record) { Employee.new }
+
+    it 'should be defined for the class' do
+      expect(ActiveRecord::Base).to respond_to(:validates_date)
+      expect(ActiveRecord::Base).to respond_to(:validates_time)
+      expect(ActiveRecord::Base).to respond_to(:validates_datetime)
+    end
+
+    it 'should defines for the instance' do
+      expect(record).to respond_to(:validates_date)
+      expect(record).to respond_to(:validates_time)
+      expect(record).to respond_to(:validates_datetime)
+    end
+
+    it "should validate a valid value string" do
+      record.birth_date = '2012-01-01'
+
+      record.valid?
+      expect(record.errors[:birth_date]).to be_empty
+    end
+
+    it "should validate a invalid value string" do
+      record.birth_date = 'not a date'
+
+      record.valid?
+      expect(record.errors[:birth_date]).not_to be_empty
+    end
+
+    it "should validate a nil value" do
+      record.birth_date = nil
+
+      record.valid?
+      expect(record.errors[:birth_date]).to be_empty
+    end
+  end
+
+  it 'should determine type for attribute' do
+    expect(Employee.timeliness_attribute_type(:birth_date)).to eq :date
+  end
+
+  context 'attribute timezone awareness' do
+    let(:klass) {
+      Class.new(ActiveRecord::Base) do
+        self.table_name = 'employees'
+        attr_accessor :some_date
+        attr_accessor :some_time
+        attr_accessor :some_datetime
+        validates_date :some_date
+        validates_time :some_time
+        validates_datetime :some_datetime
+      end
+    }
+
+    context 'for column attribute' do
+      it 'should be detected from column type' do
+        expect(klass.timeliness_attribute_timezone_aware?(:birth_date)).to be_falsey
+        expect(klass.timeliness_attribute_timezone_aware?(:birth_time)).to be_falsey
+        expect(klass.timeliness_attribute_timezone_aware?(:birth_datetime)).to be_truthy
+      end
+    end
+
+    context 'for non-column attribute' do
+      it 'should be detected from the validation type' do
+        expect(klass.timeliness_attribute_timezone_aware?(:some_date)).to be_falsey
+        expect(klass.timeliness_attribute_timezone_aware?(:some_time)).to be_falsey
+        expect(klass.timeliness_attribute_timezone_aware?(:some_datetime)).to be_truthy
+      end
+    end
+  end
+
+  context "attribute write method" do
+    class EmployeeWithCache < ActiveRecord::Base
+      self.table_name = 'employees'
+      validates_date :birth_date, :allow_blank => true
+      validates_time :birth_time, :allow_blank => true
+      validates_datetime :birth_datetime, :allow_blank => true
+    end
+
+    context 'value cache' do
+      let(:record) { EmployeeWithCache.new }
+
+      context 'for datetime column' do
+        it 'should store raw value' do
+          record.birth_datetime = datetime_string = '2010-01-01 12:30'
+
+          expect(record._timeliness_raw_value_for('birth_datetime')).to eq datetime_string
+        end
+      end
+
+      context 'for date column' do
+        it 'should store raw value' do
+          record.birth_date = date_string = '2010-01-01'
+
+          expect(record._timeliness_raw_value_for('birth_date')).to eq date_string
+        end
+      end
+
+      context 'for time column' do
+        it 'should store raw value' do
+          record.birth_time = time_string = '12:12'
+
+          expect(record._timeliness_raw_value_for('birth_time')).to eq time_string
+        end
+      end
+    end
+
+    context "with plugin parser" do
+      with_config(:use_plugin_parser, true)
+      let(:record) { EmployeeWithParser.new }
+
+      class EmployeeWithParser < ActiveRecord::Base
+        self.table_name = 'employees'
+        validates_date :birth_date, :allow_blank => true
+        validates_time :birth_time, :allow_blank => true
+        validates_datetime :birth_datetime, :allow_blank => true
+      end
+
+      context "for a date column" do
+        it 'should parse a string value' do
+          expect(Timeliness::Parser).to receive(:parse)
+
+          record.birth_date = '2010-01-01'
+        end
+
+        it 'should parse a invalid string value as nil' do
+          expect(Timeliness::Parser).to receive(:parse)
+
+          record.birth_date = 'not valid'
+        end
+
+        it 'should store a Date value after parsing string' do
+          record.birth_date = '2010-01-01'
+
+          expect(record.birth_date).to be_kind_of(Date)
+          expect(record.birth_date).to eq Date.new(2010, 1, 1)
+        end
+      end
+
+      context "for a time column" do
+        it 'should parse a string value' do
+          expect(Timeliness::Parser).to receive(:parse)
+
+          record.birth_time = '12:30'
+        end
+
+        it 'should parse a invalid string value as nil' do
+          expect(Timeliness::Parser).to receive(:parse)
+
+          record.birth_time = 'not valid'
+        end
+
+        it 'should store a Time value after parsing string' do
+          record.birth_time = '12:30'
+
+          expect(record.birth_time).to be_kind_of(Time)
+          expect(record.birth_time).to eq Time.utc(2000, 1, 1, 12, 30)
+        end
+      end
+
+      context "for a datetime column" do
+        with_config(:default_timezone, 'Australia/Melbourne')
+
+        it 'should parse a string value' do
+          expect(Timeliness::Parser).to receive(:parse)
+
+          record.birth_datetime = '2010-01-01 12:00'
+        end
+
+        it 'should parse a invalid string value as nil' do
+          expect(Timeliness::Parser).to receive(:parse)
+
+          record.birth_datetime = 'not valid'
+        end
+
+        it 'should parse string into Time value' do
+          record.birth_datetime = '2010-01-01 12:00'
+
+          expect(record.birth_datetime).to be_kind_of(Time)
+        end
+
+        it 'should parse string as current timezone' do
+          record.birth_datetime = '2010-06-01 12:00'
+
+          expect(record.birth_datetime.utc_offset).to eq Time.zone.utc_offset
+        end
+      end
+    end
+  end
+
+  context "reload" do
+    it 'should clear cache value' do
+      record = Employee.create!
+      record.birth_date = '2010-01-01'
+
+      record.reload
+
+      expect(record._timeliness_raw_value_for('birth_date')).to be_nil
+    end
+  end
+
+  context "before_type_cast method" do
+    let(:record) { Employee.new }
+
+    it 'should be defined on class if ORM supports it' do
+      expect(record).to respond_to(:birth_datetime_before_type_cast)
+    end
+
+    it 'should return original value' do
+      record.birth_datetime = date_string = '2010-01-01'
+
+      expect(record.birth_datetime_before_type_cast).to eq date_string
+    end
+
+    it 'should return attribute if no attribute assignment has been made' do
+      datetime = Time.zone.local(2010,01,01)
+      Employee.create(:birth_datetime => datetime)
+
+      record = Employee.last
+      expect(record.birth_datetime_before_type_cast).to match(/#{datetime.utc.to_s[0...-4]}/)
+    end
+
+    context "with plugin parser" do
+      with_config(:use_plugin_parser, true)
+
+      it 'should return original value' do
+        record.birth_datetime = date_string = '2010-01-31'
+
+        expect(record.birth_datetime_before_type_cast).to eq date_string
+      end
+    end
+
+  end
+
+  context "define_attribute_methods" do
+    it "returns a falsy value if the attribute methods have already been generated" do
+      expect(Employee.define_attribute_methods).to be_falsey
+    end
+  end
+end

data/spec/validates_timeliness/orm/mongoid_spec.rb

@@ -0,0 +1,189 @@
+require 'spec_helper'
+
+# Try loading mongoid and connecting. Otherwise, abort and skip spec.
+begin
+
+require 'mongoid'
+require 'validates_timeliness/orm/mongoid'
+
+Mongoid.configure do |config|
+  name = "validates_timeliness_test"
+  host = "localhost"
+  config.master = Mongo::Connection.new.db(name)
+  config.persist_in_safe_mode = false
+end
+
+describe ValidatesTimeliness, 'Mongoid' do
+
+  class Article
+    include Mongoid::Document
+    field :publish_date, :type => Date
+    field :publish_time, :type => Time
+    field :publish_datetime, :type => DateTime
+    validates_date :publish_date, :allow_nil => true
+    validates_time :publish_time, :allow_nil => true
+    validates_datetime :publish_datetime, :allow_nil => true
+  end
+
+  context "validation methods" do
+    let(:record) { Article.new }
+
+    it 'should be defined on the class' do
+      expect(Article).to respond_to(:validates_date)
+      expect(Article).to respond_to(:validates_time)
+      expect(Article).to respond_to(:validates_datetime)
+    end
+
+    it 'should be defined on the instance' do
+      expect(record).to respond_to(:validates_date)
+      expect(record).to respond_to(:validates_time)
+      expect(record).to respond_to(:validates_datetime)
+    end
+
+    it "should validate a valid value string" do
+      record.publish_date = '2012-01-01'
+
+      record.valid?
+      expect(record.errors[:publish_date]).to be_empty
+    end
+
+    it "should validate a invalid value string" do
+      begin
+        record.publish_date = 'not a date' 
+      rescue
+      end
+
+      record.valid?
+      expect(record.errors[:publish_date]).not_to be_empty
+    end
+
+    it "should validate a nil value" do
+      record.publish_date = nil
+
+      record.valid?
+      expect(record.errors[:publish_date]).to be_empty
+    end
+  end
+
+  it 'should determine type for attribute' do
+    expect(Article.timeliness_attribute_type(:publish_date)).to eq(:date)
+  end
+  
+  context "attribute write method" do
+    let(:record) { Article.new }
+
+    it 'should cache attribute raw value' do
+      record.publish_datetime = date_string = '2010-01-01'
+
+      expect(record._timeliness_raw_value_for('publish_datetime')).to eq(date_string)
+    end
+
+    context "with plugin parser" do
+      let(:record) { ArticleWithParser.new }
+
+      class ArticleWithParser
+        include Mongoid::Document
+        field :publish_date, :type => Date
+        field :publish_time, :type => Time
+        field :publish_datetime, :type => DateTime
+
+        ValidatesTimeliness.use_plugin_parser = true
+        validates_date :publish_date, :allow_nil => true
+        validates_time :publish_time, :allow_nil => true
+        validates_datetime :publish_datetime, :allow_nil => true
+        ValidatesTimeliness.use_plugin_parser = false
+      end
+
+      context "for a date column" do
+        it 'should parse a string value' do
+          expect(Timeliness::Parser).to receive(:parse)
+
+          record.publish_date = '2010-01-01'
+        end
+
+        it 'should parse a invalid string value as nil' do
+          expect(Timeliness::Parser).to receive(:parse)
+
+          record.publish_date = 'not valid'
+        end
+
+        it 'should store a Date value after parsing string' do
+          record.publish_date = '2010-01-01'
+
+          expect(record.publish_date).to be_kind_of(Date)
+          expect(record.publish_date).to eq Date.new(2010, 1, 1)
+        end
+      end
+
+      context "for a time column" do
+        it 'should parse a string value' do
+          expect(Timeliness::Parser).to receive(:parse)
+
+          record.publish_time = '12:30'
+        end
+
+        it 'should parse a invalid string value as nil' do
+          expect(Timeliness::Parser).to receive(:parse)
+
+          record.publish_time = 'not valid'
+        end
+
+        it 'should store a Time value after parsing string' do
+          record.publish_time = '12:30'
+
+          expect(record.publish_time).to be_kind_of(Time)
+          expect(record.publish_time).to eq Time.utc(2000, 1, 1, 12, 30)
+        end
+      end
+
+      context "for a datetime column" do
+        with_config(:default_timezone, 'Australia/Melbourne')
+
+        it 'should parse a string value' do
+          expect(Timeliness::Parser).to receive(:parse)
+
+          record.publish_datetime = '2010-01-01 12:00'
+        end
+
+        it 'should parse a invalid string value as nil' do
+          expect(Timeliness::Parser).to receive(:parse)
+
+          record.publish_datetime = 'not valid'
+        end
+
+        it 'should parse string into DateTime value' do
+          record.publish_datetime = '2010-01-01 12:00'
+
+          expect(record.publish_datetime).to be_kind_of(DateTime)
+        end
+
+        pending 'should parse string as current timezone' do
+          record.publish_datetime = '2010-06-01 12:00'
+
+          expect(record.publish_datetime.utc_offset).to eq Time.zone.utc_offset
+        end
+      end
+    end
+  end
+
+  context "cached value" do
+    it 'should be cleared on reload' do
+      record = Article.create!
+      record.publish_date = '2010-01-01'
+      record.reload
+      expect(record._timeliness_raw_value_for('publish_date')).to be_nil
+    end
+  end
+
+  context "before_type_cast method" do
+    it 'should not be defined if ORM does not support it' do
+      expect(Article.new).not_to respond_to(:publish_datetime_before_type_cast)
+    end
+  end
+end
+
+rescue LoadError
+  puts "Mongoid specs skipped. Mongoid not installed"
+rescue StandardError => e
+  puts "Mongoid specs skipped. MongoDB connection failed with error: #{e.message}"
+end