rufus-scheduler 3.0.8 → 3.1.0

data/spec/basics_spec.rb

@@ -19,17 +19,22 @@ describe 'basics' do
 
     it 'accepts a timezone final argument' do
 
-      pending if jruby? or ruby18?
-
-      expect(
-        tts(Time.new(2014, 1, 1, 1, 0, 0, '+01:00'))
-      ).to eq('2014-01-01 01:00:00 +0100')
-      expect(
-        tts(Time.new(2014, 8, 1, 1, 0, 0, '+01:00'))
-      ).to eq('2014-08-01 01:00:00 +0100')
-      expect(
-        tts(Time.new(2014, 8, 1, 1, 0, 0, '+01:00'))
-      ).to eq('2014-08-01 01:00:00 +0100')
+      if jruby? or ruby18?
+
+        expect(true).to be(true)
+
+      else
+
+        expect(
+          tts(Time.new(2014, 1, 1, 1, 0, 0, '+01:00'))
+        ).to eq('2014-01-01 01:00:00 +0100')
+        expect(
+          tts(Time.new(2014, 8, 1, 1, 0, 0, '+01:00'))
+        ).to eq('2014-08-01 01:00:00 +0100')
+        expect(
+          tts(Time.new(2014, 8, 1, 1, 0, 0, '+01:00'))
+        ).to eq('2014-08-01 01:00:00 +0100')
+      end
     end
   end
 

data/spec/cronline_spec.rb

@@ -5,7 +5,6 @@
 # Sat Mar 21 12:55:27 JST 2009
 #
 
-require 'tzinfo'
 require 'spec_helper'
 
 
@@ -15,6 +14,24 @@ describe Rufus::Scheduler::CronLine do
     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)
     expect(cl(line).matches?(time)).to eq(true)
   end
@@ -49,12 +66,20 @@ describe Rufus::Scheduler::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
@@ -92,7 +117,10 @@ describe Rufus::Scheduler::CronLine 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 ])
@@ -189,56 +217,34 @@ describe Rufus::Scheduler::CronLine do
 
   describe '#next_time' do
 
-    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
-
     it 'computes the next occurence correctly' do
 
-      now = Time.at(0).getutc # Thu Jan 01 00:00:00 UTC 1970
-
-      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)
-
-      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)
-
-      expect(nt('0 0 * * thu', now)).to eq(now + 604800)
-      expect(nt('00 0 * * thu', now)).to eq(now + 604800)
+      in_zone 'Europe/Berlin' do
 
-      expect(nt('0 0 * * *', now)).to eq(now + 24 * 3600)
-      expect(nt('0 24 * * *', now)).to eq(now + 24 * 3600)
+        now = Time.at(0) - 3600
 
-      now = local(2008, 12, 31, 23, 59, 59, 0)
+        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)
 
-      expect(nt('* * * * *', now)).to eq(now + 1)
-    end
+        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)
 
-    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)
 
-      expect(nt('* * * * *', now)).to eq(utc(1970, 1, 1, 0, 1))
-      expect(nt('* * * * sun', now)).to eq(utc(1970, 1, 4))
-      expect(nt('* * * * * *', now)).to eq(utc(1970, 1, 1, 0, 0, 1))
-      expect(nt('* * 13 * fri', now)).to eq(utc(1970, 2, 13))
-
-      expect(nt('10 12 13 12 *', now)).to eq(utc(1970, 12, 13, 12, 10))
-        # this one is slow (1 year == 3 seconds)
-      expect(nt('* * 1 6 *', now)).to eq(utc(1970, 6, 1))
+        now = local(2008, 12, 31, 23, 59, 59, 0)
 
-      expect(nt('0 0 * * thu', now)).to eq(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
@@ -260,9 +266,7 @@ describe Rufus::Scheduler::CronLine do
     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
+      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))
@@ -275,20 +279,6 @@ describe Rufus::Scheduler::CronLine do
       expect(nt("0 0 * * thu #{zone}", now)).to eq(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
-
     it 'computes the next time correctly when there is a sun#2 involved' do
 
       expect(nt('* * * * sun#1', local(1970, 1, 1))).to eq(local(1970, 1, 4))
@@ -375,15 +365,6 @@ describe Rufus::Scheduler::CronLine do
 
   describe '#previous_time' do
 
-    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
-
     it 'returns the previous time the cron should have triggered' do
 
       expect(
@@ -438,21 +419,21 @@ describe Rufus::Scheduler::CronLine do
 
   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
 
@@ -546,19 +527,19 @@ describe Rufus::Scheduler::CronLine do
     it 'returns the shortest delta between two occurrences' do
 
       expect(Rufus::Scheduler::CronLine.new(
-          '* * * * *').frequency).to eq(60)
+        '* * * * *').frequency).to eq(60)
       expect(Rufus::Scheduler::CronLine.new(
-          '* * * * * *').frequency).to eq(1)
+        '* * * * * *').frequency).to eq(1)
 
       expect(Rufus::Scheduler::CronLine.new(
-          '5 23 * * *').frequency).to eq(24 * 3600)
+        '5 23 * * *').frequency).to eq(24 * 3600)
       expect(Rufus::Scheduler::CronLine.new(
-          '5 * * * *').frequency).to eq(3600)
+        '5 * * * *').frequency).to eq(3600)
       expect(Rufus::Scheduler::CronLine.new(
-          '10,20,30 * * * *').frequency).to eq(600)
+        '10,20,30 * * * *').frequency).to eq(600)
 
       expect(Rufus::Scheduler::CronLine.new(
-          '10,20,30 * * * * *').frequency).to eq(10)
+        '10,20,30 * * * * *').frequency).to eq(10)
     end
   end
 
@@ -567,22 +548,30 @@ describe Rufus::Scheduler::CronLine do
     it 'returns the shortest delta between two occurrences' do
 
       expect(Rufus::Scheduler::CronLine.new(
-          '* * * * *').brute_frequency).to eq(60)
+        '* * * * *').brute_frequency).to eq(60)
       expect(Rufus::Scheduler::CronLine.new(
-          '* * * * * *').brute_frequency).to eq(1)
+        '* * * * * *').brute_frequency).to eq(1)
 
       expect(Rufus::Scheduler::CronLine.new(
-          '5 23 * * *').brute_frequency).to eq(24 * 3600)
+        '5 23 * * *').brute_frequency).to eq(24 * 3600)
       expect(Rufus::Scheduler::CronLine.new(
-          '5 * * * *').brute_frequency).to eq(3600)
+        '5 * * * *').brute_frequency).to eq(3600)
       expect(Rufus::Scheduler::CronLine.new(
-          '10,20,30 * * * *').brute_frequency).to eq(600)
+        '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
@@ -593,10 +582,6 @@ describe Rufus::Scheduler::CronLine do
     #
     it 'schedules correctly through a switch into summer time' do
 
-      #j = `zdump -v Europe/Berlin | grep "Sun Mar" | grep 2014`.split("\n")[0]
-      #j = j.match(/^.+ (Sun Mar .+ UTC) /)[1]
-        # only works on system that have a zdump...
-
       in_zone 'Europe/Berlin' do
 
         # find the summer jump
@@ -623,14 +608,14 @@ describe Rufus::Scheduler::CronLine do
         n0 = cl0.next_time(friday)
         n1 = cl1.next_time(friday)
 
-        expect(n0.strftime('%H:%M:%S %^a')).to eq('00:02:00 MON')
+        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 THU')
+          (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
@@ -676,6 +661,70 @@ describe Rufus::Scheduler::CronLine do
           (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
 

data/spec/job_cron_spec.rb

@@ -102,5 +102,27 @@ describe Rufus::Scheduler::CronJob do
       end
     end
   end
+
+  describe '.next_time' do
+
+    it 'returns the next trigger time' do
+
+      n = Time.now
+      nt = Time.parse("#{n.year}-#{n.month + 1}-01")
+
+      expect(
+        @scheduler.schedule_cron('* * 1 * *', lambda {}).next_time
+      ).to eq(nt)
+    end
+
+    it 'returns the next trigger time (first_at => Time)' do
+
+      ft = Time.parse('2100-12-31')
+
+      job = @scheduler.schedule_cron('* * 1 * *', :first_at => ft) {}
+
+      expect(job.next_time).to eq(ft)
+    end
+  end
 end
 

data/spec/job_every_spec.rb

@@ -49,6 +49,20 @@ describe Rufus::Scheduler::EveryJob do
     expect(times[2] - times[1]).to be < 3.4
   end
 
+  context 'summer time' do
+
+    it 'triggers correctly through a DST transition' do
+
+      job = Rufus::Scheduler::EveryJob.new(@scheduler, '1m', {}, lambda {})
+      t1 = ltz('America/Los_Angeles', 2015, 3, 8, 1, 55)
+      t2 = ltz('America/Los_Angeles', 2015, 3, 8, 3, 05)
+      job.next_time = t1
+      occurrences = job.occurrences(t1, t2)
+
+      expect(occurrences.length).to eq(11)
+    end
+  end
+
   context 'first_at/in' do
 
     it 'triggers for the first time at first_at' do

data/spec/job_repeat_spec.rb

@@ -189,6 +189,7 @@ describe Rufus::Scheduler::RepeatJob do
 
         sleep 0.7
 
+        #p Time.now.to_f
         #p n.to_f
         #p job.first_at.to_f
         #p ft.to_f

data/spec/lock_flock_spec.rb

@@ -0,0 +1,47 @@
+
+#
+# Specifying rufus-scheduler
+#
+# Sat Aug 16 05:43:06 JST 2014
+# added by @ecin
+#
+
+require 'spec_helper'
+
+
+describe Rufus::Scheduler::FileLock do
+
+  before :each do
+
+    @lock_path = '.rufus-scheduler.lock'
+    @lock = Rufus::Scheduler::FileLock.new(@lock_path)
+  end
+
+  after :each do
+
+    FileUtils.rm_f(@lock_path)
+    FileUtils.rm_f('lock.txt')
+  end
+
+  context ':scheduler_lock => Rufus::Scheduler::FileLock.new(path)' do
+
+    it 'writes down a .rufus-scheduler.lock file' do
+
+      @lock.lock
+
+      line = File.read(@lock_path)
+
+      expect(line).to match(/pid: #{$$}/)
+    end
+
+    it '"flocks" the lock file' do
+
+      @lock.lock
+
+      f = File.new(@lock_path, 'a')
+
+      expect(f.flock(File::LOCK_NB | File::LOCK_EX)).to eq(false)
+    end
+  end
+end
+

data/spec/lock_spec.rb

@@ -0,0 +1,59 @@
+
+#
+# Specifying rufus-scheduler
+#
+# Sat Aug 16 05:42:11 JST 2014
+# added by @ecin
+#
+
+require 'spec_helper'
+
+
+describe Rufus::Scheduler do
+
+  context "when running multiple schedulers side-by-side" do
+
+    class AlwaysLock
+      def lock; true; end
+      def unlock; true; end
+      def locked?; true; end
+    end
+
+    class NeverLock
+      def lock; false; end
+      def unlock; true; end
+      def locked?; true; end
+    end
+
+    it "only starts if it can acquire a scheduler lock" do
+
+      main = Rufus::Scheduler.new :scheduler_lock => AlwaysLock.new
+      backup = Rufus::Scheduler.new :scheduler_lock => NeverLock.new
+
+      expect(main).to be_up
+      expect(backup).to be_down
+    end
+
+    it "only triggers jobs when it can acquire a trigger lock" do
+
+      main = Rufus::Scheduler.new(:trigger_lock => AlwaysLock.new)
+      backup = Rufus::Scheduler.new(:trigger_lock => NeverLock.new)
+
+      expect(main).to be_up
+      expect(backup).to be_up
+
+      counter = 0
+      job = proc { counter += 1 }
+      main.schedule_in(0, job)
+      backup.schedule_in(0, job)
+
+      sleep 0.5
+
+      expect(main.jobs).to be_empty
+      expect(backup.jobs.count).to eq(1)
+      expect(backup.jobs.first.next_time).to be(false)
+      expect(counter).to eq(1)
+    end
+  end
+end
+