rufus-scheduler 2.0.24 → 3.1.0

data/spec/cronline_spec.rb

@@ -5,23 +5,41 @@
 # Sat Mar 21 12:55:27 JST 2009
 #
 
-require 'spec_base'
+require 'spec_helper'
 
 
-describe Rufus::CronLine do
+describe Rufus::Scheduler::CronLine do
 
   def cl(cronline_string)
-    Rufus::CronLine.new(cronline_string)
+    Rufus::Scheduler::CronLine.new(cronline_string)
+  end
+
+  def nt(cronline, now)
+    Rufus::Scheduler::CronLine.new(cronline).next_time(now)
+  end
+  def ntz(cronline, now)
+    tz = cronline.split.last
+    tu = nt(cronline, now).utc
+    in_zone(tz) { tu.getlocal }
+  end
+
+  def pt(cronline, now)
+    Rufus::Scheduler::CronLine.new(cronline).previous_time(now)
+  end
+  def ptz(cronline, now)
+    tz = cronline.split.last
+    tu = pt(cronline, now).utc
+    in_zone(tz) { tu.getlocal }
   end
 
   def match(line, time)
-    cl(line).matches?(time).should == true
+    expect(cl(line).matches?(time)).to eq(true)
   end
   def no_match(line, time)
-    cl(line).matches?(time).should == false
+    expect(cl(line).matches?(time)).to eq(false)
   end
   def to_a(line, array)
-    cl(line).to_array.should == array
+    expect(cl(line).to_array).to eq(array)
   end
 
   describe '.new' do
@@ -48,43 +66,61 @@ describe Rufus::CronLine do
 
       to_a '0 0 1 1 *', [ [0], [0], [0], [1], [1], nil, nil, nil ]
 
-      to_a '0 23-24 * * *', [ [0], [0], [23, 0], nil, nil, nil, nil, nil ]
+      if ruby18?
+        to_a '0 23-24 * * *', [ [0], [0], [0, 23], nil, nil, nil, nil, nil ]
+      else
+        to_a '0 23-24 * * *', [ [0], [0], [23, 0], nil, nil, nil, nil, nil ]
+      end
         #
         # as reported by Aimee Rose in
         # https://github.com/jmettraux/rufus-scheduler/issues/56
 
-      to_a '0 23-2 * * *', [ [0], [0], [23, 0, 1, 2], nil, nil, nil, nil, nil ]
+      if ruby18?
+        to_a '0 23-2 * * *', [ [0], [0], [0, 1, 2, 23], nil, nil, nil, nil, nil ]
+      else
+        to_a '0 23-2 * * *', [ [0], [0], [23, 0, 1, 2], nil, nil, nil, nil, nil ]
+      end
     end
 
     it 'rejects invalid weekday expressions' do
 
-      lambda { cl '0 17 * * MON_FRI' }.should raise_error
+      expect { cl '0 17 * * MON_FRI' }.to raise_error
         # underline instead of dash
 
-      lambda { cl '* * * * 9' }.should raise_error
-      lambda { cl '* * * * 0-12' }.should raise_error
-      lambda { cl '* * * * BLABLA' }.should raise_error
+      expect { cl '* * * * 9' }.to raise_error
+      expect { cl '* * * * 0-12' }.to raise_error
+      expect { cl '* * * * BLABLA' }.to raise_error
     end
 
     it 'rejects invalid cronlines' do
 
-      lambda { cl '* nada * * 9' }.should raise_error(ArgumentError)
+      expect { cl '* nada * * 9' }.to raise_error(ArgumentError)
     end
 
     it 'interprets cron strings with TZ correctly' do
 
-      to_a '* * * * * EST', [ [0], nil, nil, nil, nil, nil, nil, 'EST' ]
-      to_a '* * * * * * EST', [ nil, nil, nil, nil, nil, nil, nil, 'EST' ]
+      to_a('* * * * * EST', [ [0], nil, nil, nil, nil, nil, nil, 'EST' ])
+      to_a('* * * * * * EST', [ nil, nil, nil, nil, nil, nil, nil, 'EST' ])
+
+      to_a(
+        '* * * * * * America/Chicago',
+        [ nil, nil, nil, nil, nil, nil, nil, 'America/Chicago' ])
+      to_a(
+        '* * * * * * America/New_York',
+        [ nil, nil, nil, nil, nil, nil, nil, 'America/New_York' ])
 
-      lambda { cl '* * * * * NotATimeZone' }.should raise_error
-      lambda { cl '* * * * * * NotATimeZone' }.should raise_error
+      expect { cl '* * * * * NotATimeZone' }.to raise_error
+      expect { cl '* * * * * * NotATimeZone' }.to raise_error
     end
 
     it 'interprets cron strings with / (slashes) correctly' do
 
       to_a(
         '0 */2 * * *',
-        [ [0], [0], (0..11).collect { |e| e * 2 }, nil, nil, nil, nil, nil ])
+        [ [0], [0], (0..23).select { |e| e.even? }, nil, nil, nil, nil, nil ])
+      to_a(
+        '0 0-23/2 * * *',
+        [ [0], [0], (0..23).select { |e| e.even? }, nil, nil, nil, nil, nil ])
       to_a(
         '0 7-23/2 * * *',
         [ [0], [0], (7..23).select { |e| e.odd? }, nil, nil, nil, nil, nil ])
@@ -108,54 +144,71 @@ describe Rufus::CronLine do
         [ [0], [ 0, 10, 20, 30, 40, 50], nil, nil, nil, nil, nil, nil ])
     end
 
+    it 'rejects / for days (every other wednesday)' do
+
+      expect {
+        Rufus::Scheduler::CronLine.new('* * * * wed/2')
+      }.to raise_error(ArgumentError)
+    end
+
     it 'does not support ranges for monthdays (sun#1-sun#2)' do
 
-      lambda {
-        Rufus::CronLine.new('* * * * sun#1-sun#2')
-      }.should raise_error(ArgumentError)
+      expect {
+        Rufus::Scheduler::CronLine.new('* * * * sun#1-sun#2')
+      }.to raise_error(ArgumentError)
     end
 
     it 'accepts items with initial 0' do
 
-      to_a '09 * * * *', [ [0], [9], nil, nil, nil, nil, nil, nil ]
-      to_a '09-12 * * * *', [ [0], [9, 10, 11, 12], nil, nil, nil, nil, nil, nil ]
-      to_a '07-08 * * * *', [ [0], [7, 8], nil, nil, nil, nil, nil, nil ]
-      to_a '* */08 * * *', [ [0], nil, [0, 8, 16], nil, nil, nil, nil, nil ]
-      to_a '* */07 * * *', [ [0], nil, [0, 7, 14, 21], nil, nil, nil, nil, nil ]
-      to_a '* 01-09/04 * * *', [ [0], nil, [1, 5, 9], nil, nil, nil, nil, nil ]
-      to_a '* * * * 06', [ [0], nil, nil, nil, nil, [6], nil, nil ]
+      to_a(
+        '09 * * * *', [ [0], [9], nil, nil, nil, nil, nil, nil ])
+      to_a(
+        '09-12 * * * *', [ [0], [9, 10, 11, 12], nil, nil, nil, nil, nil, nil ])
+      to_a(
+        '07-08 * * * *', [ [0], [7, 8], nil, nil, nil, nil, nil, nil ])
+      to_a(
+        '* */08 * * *', [ [0], nil, [0, 8, 16], nil, nil, nil, nil, nil ])
+      to_a(
+        '* */07 * * *', [ [0], nil, [0, 7, 14, 21], nil, nil, nil, nil, nil ])
+      to_a(
+        '* 01-09/04 * * *', [ [0], nil, [1, 5, 9], nil, nil, nil, nil, nil ])
+      to_a(
+        '* * * * 06', [ [0], nil, nil, nil, nil, [6], nil, nil ])
     end
 
     it 'interprets cron strings with L correctly' do
 
-      to_a '* * L * *', [[0], nil, nil, ['L'], nil, nil, nil, nil ]
-      to_a '* * 2-5,L * *', [[0], nil, nil, [2,3,4,5,'L'], nil, nil, nil, nil ]
-      to_a '* * */8,L * *', [[0], nil, nil, [1,9,17,25,'L'], nil, nil, nil, nil ]
+      to_a(
+        '* * L * *', [[0], nil, nil, ['L'], nil, nil, nil, nil ])
+      to_a(
+        '* * 2-5,L * *', [[0], nil, nil, [2,3,4,5,'L'], nil, nil, nil, nil ])
+      to_a(
+        '* * */8,L * *', [[0], nil, nil, [1,9,17,25,'L'], nil, nil, nil, nil ])
     end
 
     it 'does not support ranges for L' do
 
-      lambda { cl '* * 15-L * *'}.should raise_error(ArgumentError)
-      lambda { cl '* * L/4 * *'}.should raise_error(ArgumentError)
+      expect { cl '* * 15-L * *'}.to raise_error(ArgumentError)
+      expect { cl '* * L/4 * *'}.to raise_error(ArgumentError)
     end
 
     it 'does not support multiple Ls' do
 
-      lambda { cl '* * L,L * *'}.should raise_error(ArgumentError)
+      expect { cl '* * L,L * *'}.to raise_error(ArgumentError)
     end
 
     it 'raises if L is used for something else than days' do
 
-      lambda { cl '* L * * *'}.should raise_error(ArgumentError)
+      expect { cl '* L * * *'}.to raise_error(ArgumentError)
     end
 
     it 'raises for out of range input' do
 
-      lambda { cl '60-62 * * * *'}.should raise_error(ArgumentError)
-      lambda { cl '62 * * * *'}.should raise_error(ArgumentError)
-      lambda { cl '60 * * * *'}.should raise_error(ArgumentError)
-      lambda { cl '* 25-26 * * *'}.should raise_error(ArgumentError)
-      lambda { cl '* 25 * * *'}.should raise_error(ArgumentError)
+      expect { cl '60-62 * * * *'}.to raise_error(ArgumentError)
+      expect { cl '62 * * * *'}.to raise_error(ArgumentError)
+      expect { cl '60 * * * *'}.to raise_error(ArgumentError)
+      expect { cl '* 25-26 * * *'}.to raise_error(ArgumentError)
+      expect { cl '* 25 * * *'}.to raise_error(ArgumentError)
         #
         # as reported by Aimee Rose in
         # https://github.com/jmettraux/rufus-scheduler/pull/58
@@ -164,171 +217,223 @@ describe Rufus::CronLine do
 
   describe '#next_time' do
 
-    def nt(cronline, now)
-      Rufus::CronLine.new(cronline).next_time(now)
-    end
-
     it 'computes the next occurence correctly' do
 
-      now = Time.at(0).getutc # Thu Jan 01 00:00:00 UTC 1970
+      in_zone 'Europe/Berlin' do
 
-      nt('* * * * *', now).should == now + 60
-      nt('* * * * sun', now).should == now + 259200
-      nt('* * * * * *', now).should == now + 1
-      nt('* * 13 * fri', now).should == now + 3715200
+        now = Time.at(0) - 3600
 
-      nt('10 12 13 12 *', now).should == now + 29938200
-        # this one is slow (1 year == 3 seconds)
-        #
-        # historical note:
-        # (comment made in 2006 or 2007, the underlying libs got better and
-        # that slowness is gone)
-
-      nt('0 0 * * thu', now).should == now + 604800
-
-      nt('0 0 * * *', now).should == now + 24 * 3600
-      nt('0 24 * * *', now).should == now + 24 * 3600
+        expect(nt('* * * * *', now)).to eq(now + 60)
+        expect(nt('* * * * sun', now)).to eq(now + 259200)
+        expect(nt('* * * * * *', now)).to eq(now + 1)
+        expect(nt('* * 13 * fri', now)).to eq(now + 3715200)
 
-      now = local(2008, 12, 31, 23, 59, 59, 0)
+        expect(nt('10 12 13 12 *', now)).to eq(now + 29938200)
+          # this one is slow (1 year == 3 seconds)
+          #
+          # historical note:
+          # (comment made in 2006 or 2007, the underlying libs got better and
+          # that slowness is gone)
 
-      nt('* * * * *', now).should == now + 1
-    end
-
-    it 'computes the next occurence correctly in UTC (TZ not specified)' do
+        expect(nt('0 0 * * thu', now)).to eq(now + 604800)
+        expect(nt('00 0 * * thu', now)).to eq(now + 604800)
 
-      now = utc(1970, 1, 1)
+        expect(nt('0 0 * * *', now)).to eq(now + 24 * 3600)
+        expect(nt('0 24 * * *', now)).to eq(now + 24 * 3600)
 
-      nt('* * * * *', now).should == utc(1970, 1, 1, 0, 1)
-      nt('* * * * sun', now).should == utc(1970, 1, 4)
-      nt('* * * * * *', now).should == utc(1970, 1, 1, 0, 0, 1)
-      nt('* * 13 * fri', now).should == utc(1970, 2, 13)
-
-      nt('10 12 13 12 *', now).should == utc(1970, 12, 13, 12, 10)
-        # this one is slow (1 year == 3 seconds)
-      nt('* * 1 6 *', now).should == utc(1970, 6, 1)
+        now = local(2008, 12, 31, 23, 59, 59, 0)
 
-      nt('0 0 * * thu', now).should == utc(1970, 1, 8)
+        expect(nt('* * * * *', now)).to eq(now + 1)
+      end
     end
 
     it 'computes the next occurence correctly in local TZ (TZ not specified)' do
 
       now = local(1970, 1, 1)
 
-      nt('* * * * *', now).should == local(1970, 1, 1, 0, 1)
-      nt('* * * * sun', now).should == local(1970, 1, 4)
-      nt('* * * * * *', now).should == local(1970, 1, 1, 0, 0, 1)
-      nt('* * 13 * fri', now).should == local(1970, 2, 13)
+      expect(nt('* * * * *', now)).to eq(local(1970, 1, 1, 0, 1))
+      expect(nt('* * * * sun', now)).to eq(local(1970, 1, 4))
+      expect(nt('* * * * * *', now)).to eq(local(1970, 1, 1, 0, 0, 1))
+      expect(nt('* * 13 * fri', now)).to eq(local(1970, 2, 13))
 
-      nt('10 12 13 12 *', now).should == local(1970, 12, 13, 12, 10)
+      expect(nt('10 12 13 12 *', now)).to eq(local(1970, 12, 13, 12, 10))
         # this one is slow (1 year == 3 seconds)
-      nt('* * 1 6 *', now).should == local(1970, 6, 1)
+      expect(nt('* * 1 6 *', now)).to eq(local(1970, 6, 1))
 
-      nt('0 0 * * thu', now).should == local(1970, 1, 8)
+      expect(nt('0 0 * * thu', now)).to eq(local(1970, 1, 8))
     end
 
     it 'computes the next occurence correctly in UTC (TZ specified)' do
 
       zone = 'Europe/Stockholm'
-      tz = TZInfo::Timezone.get(zone)
-      now = tz.local_to_utc(local(1970, 1, 1))
-        # Midnight in zone, UTC
-
-      nt("* * * * * #{zone}", now).should == utc(1969, 12, 31, 23, 1)
-      nt("* * * * sun #{zone}", now).should == utc(1970, 1, 3, 23)
-      nt("* * * * * * #{zone}", now).should == utc(1969, 12, 31, 23, 0, 1)
-      nt("* * 13 * fri #{zone}", now).should == utc(1970, 2, 12, 23)
-
-      nt("10 12 13 12 * #{zone}", now).should == utc(1970, 12, 13, 11, 10)
-      nt("* * 1 6 * #{zone}", now).should == utc(1970, 5, 31, 23)
-
-      nt("0 0 * * thu #{zone}", now).should == utc(1970, 1, 7, 23)
-    end
-
-    #it 'computes the next occurence correctly in local TZ (TZ specified)' do
-    #  zone = 'Europe/Stockholm'
-    #  tz = TZInfo::Timezone.get(zone)
-    #  now = tz.local_to_utc(utc(1970, 1, 1)).localtime
-    #    # Midnight in zone, local time
-    #  nt("* * * * * #{zone}", now).should == local(1969, 12, 31, 18, 1)
-    #  nt("* * * * sun #{zone}", now).should == local(1970, 1, 3, 18)
-    #  nt("* * * * * * #{zone}", now).should == local(1969, 12, 31, 18, 0, 1)
-    #  nt("* * 13 * fri #{zone}", now).should == local(1970, 2, 12, 18)
-    #  nt("10 12 13 12 * #{zone}", now).should == local(1970, 12, 13, 6, 10)
-    #  nt("* * 1 6 * #{zone}", now).should == local(1970, 5, 31, 19)
-    #  nt("0 0 * * thu #{zone}", now).should == local(1970, 1, 7, 18)
-    #end
+      now = in_zone(zone) { Time.local(1970, 1, 1) }
+
+      expect(nt("* * * * * #{zone}", now)).to eq(utc(1969, 12, 31, 23, 1))
+      expect(nt("* * * * sun #{zone}", now)).to eq(utc(1970, 1, 3, 23))
+      expect(nt("* * * * * * #{zone}", now)).to eq(utc(1969, 12, 31, 23, 0, 1))
+      expect(nt("* * 13 * fri #{zone}", now)).to eq(utc(1970, 2, 12, 23))
+
+      expect(nt("10 12 13 12 * #{zone}", now)).to eq(utc(1970, 12, 13, 11, 10))
+      expect(nt("* * 1 6 * #{zone}", now)).to eq(utc(1970, 5, 31, 23))
+
+      expect(nt("0 0 * * thu #{zone}", now)).to eq(utc(1970, 1, 7, 23))
+    end
 
     it 'computes the next time correctly when there is a sun#2 involved' do
 
-      nt('* * * * sun#1', local(1970, 1, 1)).should == local(1970, 1, 4)
-      nt('* * * * sun#2', local(1970, 1, 1)).should == local(1970, 1, 11)
+      expect(nt('* * * * sun#1', local(1970, 1, 1))).to eq(local(1970, 1, 4))
+      expect(nt('* * * * sun#2', local(1970, 1, 1))).to eq(local(1970, 1, 11))
 
-      nt('* * * * sun#2', local(1970, 1, 12)).should == local(1970, 2, 8)
+      expect(nt('* * * * sun#2', local(1970, 1, 12))).to eq(local(1970, 2, 8))
     end
 
-    it 'computes the next time correctly when there is a sun#2,sun#3 involved' do
+    it 'computes next time correctly when there is a sun#2,sun#3 involved' do
 
-      nt('* * * * sun#2,sun#3', local(1970, 1, 1)).should == local(1970, 1, 11)
-      nt('* * * * sun#2,sun#3', local(1970, 1, 12)).should == local(1970, 1, 18)
+      expect(
+        nt('* * * * sun#2,sun#3', local(1970, 1, 1))).to eq(local(1970, 1, 11))
+      expect(
+        nt('* * * * sun#2,sun#3', local(1970, 1, 12))).to eq(local(1970, 1, 18))
     end
 
     it 'understands sun#L' do
 
-      nt('* * * * sun#L', local(1970, 1, 1)).should == local(1970, 1, 25)
+      expect(nt('* * * * sun#L', local(1970, 1, 1))).to eq(local(1970, 1, 25))
     end
 
     it 'understands sun#-1' do
 
-      nt('* * * * sun#-1', local(1970, 1, 1)).should == local(1970, 1, 25)
+      expect(nt('* * * * sun#-1', local(1970, 1, 1))).to eq(local(1970, 1, 25))
     end
 
     it 'understands sun#-2' do
 
-      nt('* * * * sun#-2', local(1970, 1, 1)).should == local(1970, 1, 18)
+      expect(nt('* * * * sun#-2', local(1970, 1, 1))).to eq(local(1970, 1, 18))
     end
 
     it 'computes the next time correctly when "L" (last day of month)' do
 
-      nt('* * L * *', lo(1970, 1, 1)).should == lo(1970, 1, 31)
-      nt('* * L * *', lo(1970, 2, 1)).should == lo(1970, 2, 28)
-      nt('* * L * *', lo(1972, 2, 1)).should == lo(1972, 2, 29)
-      nt('* * L * *', lo(1970, 4, 1)).should == lo(1970, 4, 30)
+      expect(nt('* * L * *', lo(1970, 1, 1))).to eq(lo(1970, 1, 31))
+      expect(nt('* * L * *', lo(1970, 2, 1))).to eq(lo(1970, 2, 28))
+      expect(nt('* * L * *', lo(1972, 2, 1))).to eq(lo(1972, 2, 29))
+      expect(nt('* * L * *', lo(1970, 4, 1))).to eq(lo(1970, 4, 30))
+    end
+
+    it 'returns a time with subseconds chopped off' do
+
+      expect(
+        nt('* * * * *', Time.now).usec).to eq(0)
+      expect(
+        nt('* * * * *', Time.now).iso8601(10).match(/\.0+[^\d]/)).not_to eq(nil)
+    end
+
+    # New York      EST: UTC-5
+    # summer (dst)  EDT: UTC-4
+
+    # gh-127
+    #
+    it 'survives TZInfo::AmbiguousTime' do
+
+      if ruby18? or jruby?
+        expect(
+          ntz(
+            '30 1 31 10 * America/New_York',
+            ltz('America/New_York', 2004, 10, 1)
+          ).strftime('%Y-%m-%d %H:%M:%S')
+        ).to eq('2004-10-31 01:30:00')
+      else
+        expect(
+          ntz(
+            '30 1 31 10 * America/New_York',
+            ltz('America/New_York', 2004, 10, 1)
+          )
+        ).to eq(ltz('America/New_York', 2004, 10, 31, 1, 30, 0))
+      end
     end
-  end
 
-  describe '#previous_time' do
+    # gh-127
+    #
+    it 'survives TZInfo::PeriodNotFound' do
 
-    def pt(cronline, now)
-      Rufus::CronLine.new(cronline).previous_time(now)
+      expect(
+        ntz(
+          '0 2 9 3 * America/New_York',
+          ltz('America/New_York', 2014, 3, 1)
+        )
+      ).to eq(ltz('America/New_York', 2015, 3, 9, 2, 0, 0))
     end
+  end
+
+  describe '#previous_time' do
 
     it 'returns the previous time the cron should have triggered' do
 
-      pt('* * * * sun', lo(1970, 1, 1)).should == lo(1969, 12, 28, 23, 59, 00)
-      pt('* * 13 * *', lo(1970, 1, 1)).should == lo(1969, 12, 13, 23, 59, 00)
-      pt('0 12 13 * *', lo(1970, 1, 1)).should == lo(1969, 12, 13, 12, 00)
+      expect(
+        pt('* * * * sun', lo(1970, 1, 1))).to eq(lo(1969, 12, 28, 23, 59, 00))
+      expect(
+        pt('* * 13 * *', lo(1970, 1, 1))).to eq(lo(1969, 12, 13, 23, 59, 00))
+      expect(
+        pt('0 12 13 * *', lo(1970, 1, 1))).to eq(lo(1969, 12, 13, 12, 00))
+      expect(
+        pt('0 0 2 1 *', lo(1970, 1, 1))).to eq(lo(1969, 1, 2, 0, 00))
+
+      expect(
+        pt('* * * * * sun', lo(1970, 1, 1))).to eq(lo(1969, 12, 28, 23, 59, 59))
+    end
+
+    # New York      EST: UTC-5
+    # summer (dst)  EDT: UTC-4
+
+    # gh-127
+    #
+    it 'survives TZInfo::AmbiguousTime' do
+
+      if ruby18? or jruby?
+        expect(
+          ptz(
+            '30 1 31 10 * America/New_York',
+            ltz('America/New_York', 2004, 10, 31, 14, 30, 0)
+          ).strftime('%Y-%m-%d %H:%M:%S')
+        ).to eq('2004-10-31 01:30:00')
+      else
+        expect(
+          ptz(
+            '30 1 31 10 * America/New_York',
+            ltz('America/New_York', 2004, 10, 31, 14, 30, 0)
+          )
+        ).to eq(ltz('America/New_York', 2004, 10, 31, 1, 30, 0))
+      end
+    end
+
+    # gh-127
+    #
+    it 'survives TZInfo::PeriodNotFound' do
 
-      pt('* * * * * sun', lo(1970, 1, 1)).should == lo(1969, 12, 28, 23, 59, 59)
+      expect(
+        ptz(
+          '0 2 9 3 * America/New_York',
+          ltz('America/New_York', 2015, 3, 9, 12, 0, 0)
+        )
+      ).to eq(ltz('America/New_York', 2015, 3, 9, 2, 0, 0))
     end
   end
 
   describe '#matches?' do
 
-    it 'matches correctly in UTC (TZ not specified)' do
-
-      match '* * * * *', utc(1970, 1, 1, 0, 1)
-      match '* * * * sun', utc(1970, 1, 4)
-      match '* * * * * *', utc(1970, 1, 1, 0, 0, 1)
-      match '* * 13 * fri', utc(1970, 2, 13)
-
-      match '10 12 13 12 *', utc(1970, 12, 13, 12, 10)
-      match '* * 1 6 *', utc(1970, 6, 1)
-
-      match '0 0 * * thu', utc(1970, 1, 8)
-
-      match '0 0 1 1 *', utc(2012, 1, 1)
-      no_match '0 0 1 1 *', utc(2012, 1, 1, 1, 0)
-    end
+#    it 'matches correctly in UTC (TZ not specified)' do
+#
+#      match '* * * * *', utc(1970, 1, 1, 0, 1)
+#      match '* * * * sun', utc(1970, 1, 4)
+#      match '* * * * * *', utc(1970, 1, 1, 0, 0, 1)
+#      match '* * 13 * fri', utc(1970, 2, 13)
+#
+#      match '10 12 13 12 *', utc(1970, 12, 13, 12, 10)
+#      match '* * 1 6 *', utc(1970, 6, 1)
+#
+#      match '0 0 * * thu', utc(1970, 1, 8)
+#
+#      match '0 0 1 1 *', utc(2012, 1, 1)
+#      no_match '0 0 1 1 *', utc(2012, 1, 1, 1, 0)
+#    end
 
     it 'matches correctly in local TZ (TZ not specified)' do
 
@@ -380,23 +485,245 @@ describe Rufus::CronLine do
       match '* * * * sun#2,sun#3', local(1970, 1, 18)
       no_match '* * * * sun#2,sun#3', local(1970, 1, 25)
     end
+
+    it 'matches correctly for seconds' do
+
+      match '* * * * * *', local(1970, 1, 11)
+      match '* * * * * *', local(1970, 1, 11, 0, 0, 13)
+    end
+
+    it 'matches correctly for seconds / interval' do
+
+      match '*/2 * * * * *', local(1970, 1, 11)
+      match '*/5 * * * * *', local(1970, 1, 11)
+      match '*/5 * * * * *', local(1970, 1, 11, 0, 0, 0)
+      no_match '*/5 * * * * *', local(1970, 1, 11, 0, 0, 1)
+      match '*/5 * * * * *', local(1970, 1, 11, 0, 0, 5)
+      match '*/2 * * * * *', local(1970, 1, 11, 0, 0, 2)
+      match '*/2 * * * * *', local(1970, 1, 11, 0, 0, 2, 500)
+    end
   end
 
   describe '#monthdays' do
 
     it 'returns the appropriate "sun#2"-like string' do
 
-      class Rufus::CronLine
+      class Rufus::Scheduler::CronLine
         public :monthdays
       end
 
-      cl = Rufus::CronLine.new('* * * * *')
+      cl = Rufus::Scheduler::CronLine.new('* * * * *')
+
+      expect(cl.monthdays(local(1970, 1, 1))).to eq(%w[ thu#1 thu#-5 ])
+      expect(cl.monthdays(local(1970, 1, 7))).to eq(%w[ wed#1 wed#-4 ])
+      expect(cl.monthdays(local(1970, 1, 14))).to eq(%w[ wed#2 wed#-3 ])
+
+      expect(cl.monthdays(local(2011, 3, 11))).to eq(%w[ fri#2 fri#-3 ])
+    end
+  end
+
+  describe '#frequency' do
 
-      cl.monthdays(local(1970, 1, 1)).should == %w[ thu#1 thu#-5 ]
-      cl.monthdays(local(1970, 1, 7)).should == %w[ wed#1 wed#-4 ]
-      cl.monthdays(local(1970, 1, 14)).should == %w[ wed#2 wed#-3 ]
+    it 'returns the shortest delta between two occurrences' do
 
-      cl.monthdays(local(2011, 3, 11)).should == %w[ fri#2 fri#-3 ]
+      expect(Rufus::Scheduler::CronLine.new(
+        '* * * * *').frequency).to eq(60)
+      expect(Rufus::Scheduler::CronLine.new(
+        '* * * * * *').frequency).to eq(1)
+
+      expect(Rufus::Scheduler::CronLine.new(
+        '5 23 * * *').frequency).to eq(24 * 3600)
+      expect(Rufus::Scheduler::CronLine.new(
+        '5 * * * *').frequency).to eq(3600)
+      expect(Rufus::Scheduler::CronLine.new(
+        '10,20,30 * * * *').frequency).to eq(600)
+
+      expect(Rufus::Scheduler::CronLine.new(
+        '10,20,30 * * * * *').frequency).to eq(10)
+    end
+  end
+
+  describe '#brute_frequency' do
+
+    it 'returns the shortest delta between two occurrences' do
+
+      expect(Rufus::Scheduler::CronLine.new(
+        '* * * * *').brute_frequency).to eq(60)
+      expect(Rufus::Scheduler::CronLine.new(
+        '* * * * * *').brute_frequency).to eq(1)
+
+      expect(Rufus::Scheduler::CronLine.new(
+        '5 23 * * *').brute_frequency).to eq(24 * 3600)
+      expect(Rufus::Scheduler::CronLine.new(
+        '5 * * * *').brute_frequency).to eq(3600)
+      expect(Rufus::Scheduler::CronLine.new(
+        '10,20,30 * * * *').brute_frequency).to eq(600)
+
+      #Rufus::Scheduler::CronLine.new(
+      #    '10,20,30 * * * * *').brute_frequency.should == 10
+        #
+        # takes > 20s ...
+    end
+
+    # some combos only appear every other year...
+    #
+    it 'does not go into an infinite loop' do
+
+      expect(Rufus::Scheduler::CronLine.new(
+        '1 2 3 4 5').brute_frequency).to eq(31622400)
+    end
+  end
+
+  context 'summer time' do
+
+    # let's assume summer time jumps always occur on sundays
+
+    # cf gh-114
+    #
+    it 'schedules correctly through a switch into summer time' do
+
+      in_zone 'Europe/Berlin' do
+
+        # find the summer jump
+
+        j = Time.parse('2014-02-28 12:00')
+        loop do
+          jj = j + 24 * 3600
+          break if jj.isdst
+          j = jj
+        end
+
+        # test
+
+        friday = j - 24 * 3600 # one day before
+
+        # verify the playground...
+        #
+        expect(friday.isdst).to eq(false)
+        expect((friday + 24 * 3600 * 3).isdst).to eq(true)
+
+        cl0 = Rufus::Scheduler::CronLine.new('02 00 * * 1,2,3,4,5')
+        cl1 = Rufus::Scheduler::CronLine.new('45 08 * * 1,2,3,4,5')
+
+        n0 = cl0.next_time(friday)
+        n1 = cl1.next_time(friday)
+
+        expect(n0.strftime('%H:%M:%S %^a')).to eq('00:02:00 TUE')
+        expect(n1.strftime('%H:%M:%S %^a')).to eq('08:45:00 MON')
+
+        expect(n0.isdst).to eq(true)
+        expect(n1.isdst).to eq(true)
+
+        expect(
+          (n0 - 24 * 3600 * 3).strftime('%H:%M:%S %^a')).to eq('23:02:00 FRI')
+        expect(
+          (n1 - 24 * 3600 * 3).strftime('%H:%M:%S %^a')).to eq('07:45:00 FRI')
+      end
+    end
+
+    it 'schedules correctly through a switch out of summer time' do
+
+      in_zone 'Europe/Berlin' do
+
+        # find the winter jump
+
+        j = Time.parse('2014-08-31 12:00')
+        loop do
+          jj = j + 24 * 3600
+          break if jj.isdst == false
+          j = jj
+        end
+
+        # test
+
+        friday = j - 24 * 3600 # one day before
+
+        # verify the playground...
+        #
+        expect(friday.isdst).to eq(true)
+        expect((friday + 24 * 3600 * 3).isdst).to eq(false)
+
+        cl0 = Rufus::Scheduler::CronLine.new('02 00 * * 1,2,3,4,5')
+        cl1 = Rufus::Scheduler::CronLine.new('45 08 * * 1,2,3,4,5')
+
+        n0 = cl0.next_time(friday)
+        n1 = cl1.next_time(friday)
+
+        expect(n0.strftime('%H:%M:%S %^a')).to eq('00:02:00 MON')
+        expect(n1.strftime('%H:%M:%S %^a')).to eq('08:45:00 MON')
+
+        expect(n0.isdst).to eq(false)
+        expect(n1.isdst).to eq(false)
+
+        expect(
+          (n0 - 24 * 3600 * 3).strftime('%H:%M:%S %^a')).to eq('01:02:00 FRI')
+        expect(
+          (n1 - 24 * 3600 * 3).strftime('%H:%M:%S %^a')).to eq('09:45:00 FRI')
+      end
+    end
+
+    it 'correctly increments through a DST transition' do
+
+      expect(
+        nt('* * * * * America/Los_Angeles', Time.utc(2015, 3, 8, 9, 59))
+      ).to eq(Time.utc(2015, 3, 8, 10, 00))
+    end
+
+    it 'correctly increments every minute through a DST transition' do
+
+      in_zone 'America/Los_Angeles' do
+
+        line = cl('* * * * * America/Los_Angeles')
+
+        t = Time.local(2015, 3, 8, 1, 57)
+
+        points =
+          [ 0, 1, 2, 3 ].collect do
+            t = line.next_time(t)
+            t.strftime('%H:%M:%Sl') + ' ' + t.dup.utc.strftime('%H:%M:%Su')
+          end
+
+        expect(points).to eq(
+          [
+            '01:58:00l 09:58:00u',
+            '01:59:00l 09:59:00u',
+            '03:00:00l 10:00:00u',
+            '03:01:00l 10:01:00u'
+          ]
+        )
+      end
+    end
+
+    it 'correctly decrements through a DST transition' do
+
+      expect(
+        pt('* * * * * America/Los_Angeles', Time.utc(2015, 3, 8, 10, 00))
+      ).to eq(Time.utc(2015, 3, 8, 9, 59))
+    end
+
+    it 'correctly decrements every minute through a DST transition' do
+
+      in_zone 'America/Los_Angeles' do
+
+        line = cl('* * * * * America/Los_Angeles')
+
+        t = Time.local(2015, 3, 8, 3, 2)
+
+        points =
+          [ 0, 1, 2, 3 ].collect do
+            t = line.previous_time(t)
+            t.strftime('%H:%M:%Sl') + ' ' + t.dup.utc.strftime('%H:%M:%Su')
+          end
+
+        expect(points).to eq(
+          [
+            '03:01:00l 10:01:00u',
+            '03:00:00l 10:00:00u',
+            '01:59:00l 09:59:00u',
+            '01:58:00l 09:58:00u'
+          ]
+        )
+      end
     end
   end
 end