More robust specs across Ruby/Rails versions

Avoid calling on ActiveSupport in specs unless it's necessary: methods
like `1.day` no longer work for RAILS_VERSION=3.2 on Ruby 2.4.

Author: avit

spec/examples/active_support_spec.rb

@@ -66,7 +66,7 @@ module IceCube
     end
 
     it 'should use the correct zone for next_occurrences before start_time' do
-      future_time = Time.zone.now.beginning_of_day + 1.day
+      future_time = Time.zone.now.beginning_of_day + IceCube::ONE_DAY
       schedule = Schedule.new(future_time)
       schedule.add_recurrence_rule Rule.daily
       schedule.next_occurrence.time_zone.should == schedule.start_time.time_zone
@@ -105,23 +105,23 @@ module IceCube
       end
 
       it 'uses schedule zone for remaining_occurrences' do
-        remaining_occurrences = schedule.remaining_occurrences(reference_time + 1.day)
+        remaining_occurrences = schedule.remaining_occurrences(reference_time + IceCube::ONE_DAY)
         remaining_occurrences.should == [Time.utc(2013, 1, 2), Time.utc(2013, 1, 3)]
         remaining_occurrences.each do |t|
           t.time_zone.should == schedule.start_time.time_zone
         end
       end
 
       it 'uses schedule zone for occurrences' do
-        occurrences = schedule.occurrences(reference_time + 1.day)
+        occurrences = schedule.occurrences(reference_time + IceCube::ONE_DAY)
         occurrences.should == [Time.utc(2013, 1, 1), Time.utc(2013, 1, 2)]
         occurrences.each do |t|
           t.time_zone.should == schedule.start_time.time_zone
         end
       end
 
       it 'uses schedule zone for occurrences_between' do
-        occurrences_between = schedule.occurrences_between(reference_time, reference_time + 1.day)
+        occurrences_between = schedule.occurrences_between(reference_time, reference_time + IceCube::ONE_DAY)
         occurrences_between.should == [Time.utc(2013, 1, 1), Time.utc(2013, 1, 2)]
         occurrences_between.each do |t|
           t.time_zone.should == schedule.start_time.time_zone
@@ -131,7 +131,7 @@ module IceCube
       it "uses schedule zone for occurrences_between with a rule terminated by #count" do
         utc = Time.utc(2013, 1, 1).in_time_zone('UTC')
         s = Schedule.new(utc) { |s| s.add_recurrence_rule Rule.daily.count(3) }
-        occurrences_between = s.occurrences_between(reference_time, reference_time + 1.day)
+        occurrences_between = s.occurrences_between(reference_time, reference_time + IceCube::ONE_DAY)
         occurrences_between.should == [Time.utc(2013, 1, 1), Time.utc(2013, 1, 2)]
         occurrences_between.each do |t|
           t.time_zone.should == schedule.start_time.time_zone
@@ -141,7 +141,7 @@ module IceCube
       it "uses schedule zone for occurrences_between with a rule terminated by #until" do
         utc = Time.utc(2013, 1, 1).in_time_zone('UTC')
         s = Schedule.new(utc) { |s| s.add_recurrence_rule Rule.daily.until(utc.advance(:days => 3)) }
-        occurrences_between = s.occurrences_between(reference_time, reference_time + 1.day)
+        occurrences_between = s.occurrences_between(reference_time, reference_time + IceCube::ONE_DAY)
         occurrences_between.should == [Time.utc(2013, 1, 1), Time.utc(2013, 1, 2)]
         occurrences_between.each do |t|
           t.time_zone.should == schedule.start_time.time_zone
@@ -151,7 +151,7 @@ module IceCube
       it "uses schedule zone for occurrences_between with an unterminated rule" do
         utc = Time.utc(2013, 1, 1).in_time_zone('UTC')
         s = Schedule.new(utc) { |s| s.add_recurrence_rule Rule.daily }
-        occurrences_between = s.occurrences_between(reference_time, reference_time + 1.day)
+        occurrences_between = s.occurrences_between(reference_time, reference_time + IceCube::ONE_DAY)
         occurrences_between.should == [Time.utc(2013, 1, 1), Time.utc(2013, 1, 2)]
         occurrences_between.each do |t|
           t.time_zone.should == schedule.start_time.time_zone

spec/examples/from_ical_spec.rb

@@ -89,7 +89,7 @@ module IceCube
     it 'should return no occurrences after daily interval with count is over' do
       schedule = IceCube::Schedule.new(Time.now)
       schedule.add_recurrence_rule(IceCube::Rule.from_ical("FREQ=DAILY;COUNT=5"))
-      schedule.occurrences_between(Time.now + 7.days, Time.now + 14.days).count.should == 0
+      schedule.occurrences_between(Time.now + (IceCube::ONE_DAY * 7), Time.now + (IceCube::ONE_DAY * 14)).count.should == 0
     end
 
   end
@@ -177,7 +177,7 @@ def sorted_ical(ical)
         start_time = Time.now
 
         schedule = IceCube::Schedule.new(start_time)
-        schedule.add_recurrence_rule(IceCube::Rule.daily.until(start_time + 15.days))
+        schedule.add_recurrence_rule(IceCube::Rule.daily.until(start_time + (IceCube::ONE_DAY * 15)))
 
         ical = schedule.to_ical
         sorted_ical(IceCube::Schedule.from_ical(ical).to_ical).should eq(sorted_ical(ical))
@@ -357,7 +357,7 @@ def sorted_ical(ical)
 
         schedule = IceCube::Schedule.new(start_time)
         schedule.add_recurrence_rule(IceCube::Rule.daily)
-        schedule.add_exception_time(Time.now + 2.days)
+        schedule.add_exception_time(Time.now + (IceCube::ONE_DAY * 2))
 
         ical = schedule.to_ical
         sorted_ical(IceCube::Schedule.from_ical(ical).to_ical).should eq(sorted_ical(ical))

spec/examples/ice_cube_spec.rb

@@ -334,14 +334,14 @@
   describe "using occurs_between with a biweekly schedule" do
     [[0, 1, 2], [0, 6, 1], [5, 1, 6], [6, 5, 7]].each do |wday, offset, lead|
       start_week    = Time.utc(2014, 1, 5)
-      expected_week =  start_week + 2.weeks
+      expected_week =  start_week + (IceCube::ONE_DAY * 14)
       offset_wday   = (wday + offset) % 7
 
       context "starting on weekday #{wday} selecting weekday #{offset} with a #{lead} day advance window" do
         let(:biweekly)      { Rule.weekly(2).day(0, 1, 2, 3, 4, 5, 6) }
-        let(:schedule)      { Schedule.new(start_week + wday.days) { |s| s.rrule biweekly } }
-        let(:expected_date) { expected_week + offset_wday.days }
-        let(:range)         { [expected_date - lead.days, expected_date] }
+        let(:schedule)      { Schedule.new(start_week + (IceCube::ONE_DAY * wday)) { |s| s.rrule biweekly } }
+        let(:expected_date) { expected_week + (IceCube::ONE_DAY * offset_wday) }
+        let(:range)         { [expected_date - (IceCube::ONE_DAY * lead), expected_date] }
 
         it "should include weekday #{offset_wday} of the expected week" do
           expect(schedule.occurrences_between(range.first, range.last)).to include expected_date

spec/examples/monthly_rule_spec.rb

@@ -36,7 +36,7 @@ module IceCube
       schedule = double(start_time: t0 = Time.utc(2013, 5, 17))
       rule = Rule.monthly(3)
       rule.interval(1)
-      rule.next_time(t0 + 1, schedule, nil).should == t0 + 31.days
+      rule.next_time(t0 + 1, schedule, nil).should == t0 + (IceCube::ONE_DAY * 31)
     end
 
     it 'should produce the correct number of days for @interval = 1' do

spec/examples/yearly_rule_spec.rb

@@ -31,7 +31,7 @@
     schedule = double(start_time: t0 = Time.utc(2013, 5, 1))
     rule = Rule.yearly(3)
     rule.interval(1)
-    rule.next_time(t0 + 1, schedule, nil).should == t0 + 365.days
+    rule.next_time(t0 + 1, schedule, nil).should == t0 + (IceCube::ONE_DAY * 365)
   end
 
   it 'should be able to specify complex yearly rules' do