validates_timeliness 4.1.1 → 5.0.0.alpha1

data/spec/validates_timeliness/extensions/date_time_select_spec.rb

@@ -20,8 +20,8 @@ RSpec.describe 'ValidatesTimeliness::Extensions::DateTimeSelect' do
         "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)
+      @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
@@ -34,26 +34,26 @@ RSpec.describe 'ValidatesTimeliness::Extensions::DateTimeSelect' do
         "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)
+      @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)
+      @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)
+      @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)
+      @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
@@ -66,8 +66,8 @@ RSpec.describe 'ValidatesTimeliness::Extensions::DateTimeSelect' do
         "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)
+      @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
@@ -77,26 +77,26 @@ RSpec.describe 'ValidatesTimeliness::Extensions::DateTimeSelect' do
         "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)
+      @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)
+      @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)
+      @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)
+      @output = date_select(:person, :birth_date, include_blank: true)
       should_not_have_datetime_selected(:birth_time, :year, :month, :day)
     end
 
@@ -106,8 +106,8 @@ RSpec.describe 'ValidatesTimeliness::Extensions::DateTimeSelect' do
         "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')
+      @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
@@ -128,33 +128,33 @@ RSpec.describe 'ValidatesTimeliness::Extensions::DateTimeSelect' do
         "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)
+      @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)
+      @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)
+      @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]
+      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]", 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]
+      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

data/spec/validates_timeliness/extensions/multiparameter_handler_spec.rb

@@ -1,36 +1,36 @@
 RSpec.describe 'ValidatesTimeliness::Extensions::MultiparameterHandler' do
 
   context "time column" do
-    it 'should assign a string value for invalid date portion' do
+    it 'should be nil 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'
+      expect(employee.birth_datetime).to be_nil
     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)
+      expect(employee.birth_datetime).to eq Time.zone.local(2000, 2, 28, 12, 0, 0)
     end
 
-    it 'should assign a string value for incomplete time' do
+    it 'should be nil for incomplete date portion' do
       employee = record_with_multiparameter_attribute(:birth_datetime, [2000, nil, nil])
-      expect(employee.birth_datetime_before_type_cast).to eq '2000-00-00'
+      expect(employee.birth_datetime).to be_nil
     end
   end
 
   context "date column" do
-    it 'should assign a string value for invalid date' do
+    it 'should assign nil 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'
+      expect(employee.birth_date).to be_nil
     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)
+      expect(employee.birth_date).to eq Date.new(2000, 2, 28)
     end
 
-    it 'should assign a string value for incomplete date' do
+    it 'should assign hash values 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'
+      expect(employee.birth_date).to be_nil
     end
   end
 

data/spec/validates_timeliness/orm/active_record_spec.rb

@@ -1,5 +1,4 @@
 RSpec.describe ValidatesTimeliness, 'ActiveRecord' do
-
   context "validation methods" do
     let(:record) { Employee.new }
 
@@ -26,6 +25,7 @@ RSpec.describe ValidatesTimeliness, 'ActiveRecord' do
       record.birth_date = 'not a date'
 
       record.valid?
+      expect(record.birth_date_before_type_cast).to eq 'not a date'
       expect(record.errors[:birth_date]).not_to be_empty
     end
 
@@ -37,10 +37,6 @@ RSpec.describe ValidatesTimeliness, 'ActiveRecord' do
     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
@@ -53,22 +49,6 @@ RSpec.describe ValidatesTimeliness, 'ActiveRecord' do
         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
@@ -79,34 +59,6 @@ RSpec.describe ValidatesTimeliness, 'ActiveRecord' do
       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.read_timeliness_attribute_before_type_cast('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.read_timeliness_attribute_before_type_cast('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.read_timeliness_attribute_before_type_cast('birth_time')).to eq time_string
-        end
-      end
-    end
-
     context "with plugin parser" do
       with_config(:use_plugin_parser, true)
       let(:record) { EmployeeWithParser.new }
@@ -118,17 +70,23 @@ RSpec.describe ValidatesTimeliness, 'ActiveRecord' do
         validates_datetime :birth_datetime, :allow_blank => true
       end
 
+      before do
+        allow(Timeliness::Parser).to receive(:parse).and_call_original
+      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'
+          expect(record.birth_date).to eq(Date.new(2010, 1, 1))
+
+          expect(Timeliness::Parser).to have_received(:parse)
         end
 
         it 'should parse a invalid string value as nil' do
-          expect(Timeliness::Parser).to receive(:parse)
-
           record.birth_date = 'not valid'
+          expect(record.birth_date).to be_nil
+
+          expect(Timeliness::Parser).to have_received(:parse)
         end
 
         it 'should store a Date value after parsing string' do
@@ -140,45 +98,85 @@ RSpec.describe ValidatesTimeliness, 'ActiveRecord' do
       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'
+        around do |example|
+          time_zone_aware_types = ActiveRecord::Base.time_zone_aware_types.dup
+          example.call
+          ActiveRecord::Base.time_zone_aware_types = time_zone_aware_types
         end
 
-        it 'should parse a invalid string value as nil' do
-          expect(Timeliness::Parser).to receive(:parse)
+        context 'timezone aware' do
+          with_config(:default_timezone, 'Australia/Melbourne')
+
+          before do
+            unless ActiveRecord::Base.time_zone_aware_types.include?(:time)
+              ActiveRecord::Base.time_zone_aware_types.push(:time)
+            end
+          end
+
+          it 'should parse a string value' do
+            record.birth_time = '12:30'
+
+            expect(record.birth_time).to eq('12:30'.in_time_zone)
+            expect(Timeliness::Parser).to have_received(:parse)
+          end
+
+          it 'should parse a invalid string value as nil' do
+            record.birth_time = 'not valid'
 
-          record.birth_time = 'not valid'
+            expect(record.birth_time).to be_nil
+            expect(Timeliness::Parser).to have_received(:parse)
+          end
+
+          it 'should store a Time value after parsing string' do
+            record.birth_time = '12:30'
+
+            expect(record.birth_time).to eq('12:30'.in_time_zone)
+            expect(record.birth_time.utc_offset).to eq '12:30'.in_time_zone.utc_offset
+          end
         end
 
-        it 'should store a Time value after parsing string' do
-          record.birth_time = '12:30'
+        skip 'not timezone aware' do
+          before do
+            ActiveRecord::Base.time_zone_aware_types.delete(:time)
+          end
+
+          it 'should parse a string value' do
+            record.birth_time = '12:30'
+
+            expect(record.birth_time).to eq(Time.utc(2000,1,1,12,30))
+            expect(Timeliness::Parser).to have_received(:parse)
+          end
+
+          it 'should parse a invalid string value as nil' do
+            record.birth_time = 'not valid'
 
-          expect(record.birth_time).to be_kind_of(Time)
-          expect(record.birth_time).to eq Time.utc(2000, 1, 1, 12, 30)
+            expect(record.birth_time).to be_nil
+            expect(Timeliness::Parser).to have_received(:parse)
+          end
+
+          it 'should store a Time value in utc' do
+            record.birth_time = '12:30'
+
+            expect(record.birth_time.utc_offset).to eq Time.now.utc.utc_offset
+          end
         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)
-
+        it 'should parse a string value into Time value' do
           record.birth_datetime = '2010-01-01 12:00'
+
+          expect(record.birth_datetime).to eq Time.zone.local(2010,1,1,12,00)
+          expect(Timeliness::Parser).to have_received(:parse)
         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)
+          expect(record.birth_datetime).to be_nil
+          expect(Timeliness::Parser).to have_received(:parse)
         end
 
         it 'should parse string as current timezone' do
@@ -189,66 +187,4 @@ RSpec.describe ValidatesTimeliness, 'ActiveRecord' do
       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.read_timeliness_attribute_before_type_cast('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
-
-  context "undefine_attribute_methods" do
-    it "returns remove attribute methods that have already been generated" do
-      Employee.define_attribute_methods
-
-      expect(Employee.instance_methods).to include(:birth_datetime)
-
-      Employee.undefine_attribute_methods
-
-      expect(Employee.instance_methods).to_not include(:birth_datetime)
-    end
-  end
 end