rufus-scheduler 2.0.6 → 2.0.7

data/spec/cronline_spec.rb

@@ -5,63 +5,198 @@
 # Sat Mar 21 12:55:27 JST 2009
 #
 
-require File.dirname(__FILE__) + '/spec_base'
-
-
-def cl (cronline_string)
-  Rufus::CronLine.new(cronline_string)
-end
+require File.join(File.dirname(__FILE__), 'spec_base')
 
 
 describe Rufus::CronLine do
 
-  def should (line, array)
+  def cl(cronline_string)
+    Rufus::CronLine.new(cronline_string)
+  end
 
-    cl(line).to_array.should.equal(array)
+  def match(line, time)
+    cl(line).matches?(time).should == true
+  end
+  def to_a(line, array)
+    cl(line).to_array.should == array
   end
 
-  it 'should interpret cron strings correctly' do
-
-    should '* * * * *', [ [0], nil, nil, nil, nil, nil ]
-    should '10-12 * * * *', [ [0], [10, 11, 12], nil, nil, nil, nil ]
-    should '* * * * sun,mon', [ [0], nil, nil, nil, nil, [0, 1] ]
-    should '* * * * mon-wed', [ [0], nil, nil, nil, nil, [1, 2, 3] ]
-    should '* * * * 7', [ [0], nil, nil, nil, nil, [0] ]
-    should '* * * * 0', [ [0], nil, nil, nil, nil, [0] ]
-    should '* * * * 0,1', [ [0], nil, nil, nil, nil, [0,1] ]
-    should '* * * * 7,1', [ [0], nil, nil, nil, nil, [0,1] ]
-    should '* * * * 7,0', [ [0], nil, nil, nil, nil, [0] ]
-    should '* * * * sun,2-4', [ [0], nil, nil, nil, nil, [0, 2, 3, 4] ]
-
-    should '* * * * sun,mon-tue', [ [0], nil, nil, nil, nil, [0, 1, 2] ]
-
-    should '* * * * * *', [ nil, nil, nil, nil, nil, nil ]
-    should '1 * * * * *', [ [1], nil, nil, nil, nil, nil ]
-    should '7 10-12 * * * *', [ [7], [10, 11, 12], nil, nil, nil, nil ]
-    should '1-5 * * * * *', [ [1,2,3,4,5], nil, nil, nil, nil, nil ]
+  def local(*args)
+    Time.local(*args)
   end
-end
+  def utc(*args)
+    Time.utc(*args)
+  end
+
+  describe '.new' do
+
+    it 'interprets cron strings correctly' do
+
+      to_a '* * * * *', [ [0], nil, nil, nil, nil, nil, nil ]
+      to_a '10-12 * * * *', [ [0], [10, 11, 12], nil, nil, nil, nil, nil ]
+      to_a '* * * * sun,mon', [ [0], nil, nil, nil, nil, [0, 1], nil ]
+      to_a '* * * * mon-wed', [ [0], nil, nil, nil, nil, [1, 2, 3], nil ]
+      to_a '* * * * 7', [ [0], nil, nil, nil, nil, [0], nil ]
+      to_a '* * * * 0', [ [0], nil, nil, nil, nil, [0], nil ]
+      to_a '* * * * 0,1', [ [0], nil, nil, nil, nil, [0,1], nil ]
+      to_a '* * * * 7,1', [ [0], nil, nil, nil, nil, [0,1], nil ]
+      to_a '* * * * 7,0', [ [0], nil, nil, nil, nil, [0], nil ]
+      to_a '* * * * sun,2-4', [ [0], nil, nil, nil, nil, [0, 2, 3, 4], nil ]
+
+      to_a '* * * * sun,mon-tue', [ [0], nil, nil, nil, nil, [0, 1, 2], nil ]
+
+      to_a '* * * * * *', [ nil, nil, nil, nil, nil, nil, nil ]
+      to_a '1 * * * * *', [ [1], nil, nil, nil, nil, nil, nil ]
+      to_a '7 10-12 * * * *', [ [7], [10, 11, 12], nil, nil, nil, nil, nil ]
+      to_a '1-5 * * * * *', [ [1,2,3,4,5], nil, nil, nil, nil, nil, nil ]
+    end
+
+    it 'interprets cron strings with TZ correctly' do
+
+      to_a '* * * * * EST', [ [0], nil, nil, nil, nil, nil, 'EST' ]
+      to_a '* * * * * * EST', [ nil, nil, nil, nil, nil, nil, 'EST' ]
+
+      lambda { cl '* * * * * NotATimeZone' }.should raise_error
+      lambda { cl '* * * * * * NotATimeZone' }.should raise_error
+    end
+  end
+
+  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
+
+      nt('* * * * *', now).should == now + 60
+      nt('* * * * sun', now).should == now + 259200
+      nt('* * * * * *', now).should == now + 1
+      nt('* * 13 * fri', now).should == now + 3715200
+
+      nt('10 12 13 12 *', now).should == now + 29938200
+        # this one is slow (1 year == 3 seconds)
+
+      nt('0 0 * * thu', now).should == now + 604800
+
+      now = local(2008, 12, 31, 23, 59, 59, 0)
+
+      nt('* * * * *', now).should == now + 1
+    end
 
-describe 'Rufus::CronLine#next_time' do
+#
+# the specs that follow are from Tanzeeb Khalili
+#
+
+    it 'computes the next occurence correctly in UTC (TZ not specified)' do
+
+      now = utc(1970, 1, 1)
+
+      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)
+
+      nt('0 0 * * thu', now).should == utc(1970, 1, 8)
+    end
 
-  it 'should compute next occurence correctly' do
+    it 'computes the next occurence correctly in local TZ (TZ not specified)' do
 
-    now = Time.at(0).utc # Thu Jan 01 00:00:00 UTC 1970
+      now = local(1970, 1, 1)
 
-    cl('* * * * *').next_time(now).should.equal(now + 60)
-    cl('* * * * sun').next_time(now).should.equal(now + 259200)
-    cl('* * * * * *').next_time(now).should.equal(now + 1)
-    cl('* * 13 * fri').next_time(now).should.equal(now + 3715200)
+      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)
 
-    cl('10 12 13 12 *').next_time(now).should.equal(now + 29938200)
-      # this one is slow (1 year == 3 seconds)
+      nt('10 12 13 12 *', now).should == local(1970, 12, 13, 12, 10)
+        # this one is slow (1 year == 3 seconds)
+      nt('* * 1 6 *', now).should == local(1970, 6, 1)
 
-    cl('0 0 * * thu').next_time(now).should.equal(now + 604800)
+      nt('0 0 * * thu', now).should == local(1970, 1, 8)
+    end
 
-    now = Time.local(2008, 12, 31, 23, 59, 59, 0)
+    it 'computes the next occurence correctly in UTC (TZ specified)' do
 
-    cl('* * * * *').next_time(now).should.equal(now + 1)
+      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
   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)
+    end
+
+    it 'matches correctly in local TZ (TZ not specified)' do
+
+      match '* * * * *', local(1970, 1, 1, 0, 1)
+      match '* * * * sun', local(1970, 1, 4)
+      match '* * * * * *', local(1970, 1, 1, 0, 0, 1)
+      match '* * 13 * fri', local(1970, 2, 13)
+
+      match '10 12 13 12 *', local(1970, 12, 13, 12, 10)
+      match '* * 1 6 *', local(1970, 6, 1)
+
+      match '0 0 * * thu', local(1970, 1, 8)
+    end
+
+    it 'matches correctly in UTC (TZ specified)' do
+
+      zone = 'Europe/Stockholm'
+
+      match "* * * * * #{zone}", utc(1969, 12, 31, 23, 1)
+      match "* * * * sun #{zone}", utc(1970, 1, 3, 23)
+      match "* * * * * * #{zone}", utc(1969, 12, 31, 23, 0, 1)
+      match "* * 13 * fri #{zone}", utc(1970, 2, 12, 23)
+
+      match "10 12 13 12 * #{zone}", utc(1970, 12, 13, 11, 10)
+      match "* * 1 6 * #{zone}", utc(1970, 5, 31, 23)
+
+      match "0 0 * * thu #{zone}", utc(1970, 1, 7, 23)
+    end
+  end
 end
 

data/spec/every_spec.rb

@@ -5,32 +5,32 @@
 # Sun Mar 22 12:26:07 JST 2009
 #
 
-require File.dirname(__FILE__) + '/spec_base'
+require File.join(File.dirname(__FILE__), 'spec_base')
 
 
 describe "#{SCHEDULER_CLASS}#every" do
 
-  before do
+  before(:each) do
     @s = start_scheduler
   end
-  after do
+  after(:each) do
     stop_scheduler(@s)
   end
 
-  it 'should have job ids with the class name in it' do
+  it 'has job ids with the class name in it' do
 
     j0 = @s.every(1) {}
-    j0.job_id.should.match(/Rufus::Scheduler::EveryJob/)
+    j0.job_id.should match(/Rufus::Scheduler::EveryJob/)
   end
 
-  it 'should compute frequency' do
+  it 'computes frequency' do
 
     job = @s.every '2h1m' do
     end
-    job.frequency.should.equal(7260)
+    job.frequency.should == 7260
   end
 
-  it 'should schedule every 1s' do
+  it 'schedules every 1s' do
 
     var = 0
 
@@ -40,10 +40,10 @@ describe "#{SCHEDULER_CLASS}#every" do
 
     sleep 3.7
 
-    var.should.equal(3)
+    var.should == 3
   end
 
-  it 'should be punctilious' do
+  it 'is punctilious' do
 
     hits = []
 
@@ -58,10 +58,10 @@ describe "#{SCHEDULER_CLASS}#every" do
     hits.each { |h| f = h; deltas << (f - hh) if hh; hh = f }
 
     #puts; p deltas
-    deltas.max.should.satisfy { |d| d < 1.200 }
+    deltas.max.should satisfy { |d| d < 1.200 }
   end
 
-  it 'should unschedule' do
+  it 'unschedules' do
 
     var = 0
 
@@ -73,25 +73,25 @@ describe "#{SCHEDULER_CLASS}#every" do
 
     @s.unschedule(job.job_id)
 
-    var.should.equal(2)
+    var.should == 2
 
     sleep 1.7
 
-    var.should.equal(2)
+    var.should == 2
   end
 
-  it 'should accept tags for jobs' do
+  it 'accepts tags for jobs' do
 
     job = @s.every '1s', :tags => 'spec' do
     end
 
     wait_next_tick
 
-    @s.find_by_tag('spec').size.should.equal(1)
-    @s.find_by_tag('spec').first.job_id.should.equal(job.job_id)
+    @s.find_by_tag('spec').size.should == 1
+    @s.find_by_tag('spec').first.job_id.should == job.job_id
   end
 
-  it 'should honour :first_at' do
+  it 'honours :first_at' do
 
     counter = 0
 
@@ -100,13 +100,13 @@ describe "#{SCHEDULER_CLASS}#every" do
     end
 
     sleep 1
-    counter.should.equal(0)
+    counter.should == 0
 
     sleep 2.5
-    counter.should.equal(2)
+    counter.should == 2
   end
 
-  it 'should honour :first_in' do
+  it 'honours :first_in' do
 
     counter = 0
 
@@ -115,13 +115,13 @@ describe "#{SCHEDULER_CLASS}#every" do
     end
 
     sleep 1
-    counter.should.equal(0)
+    counter.should == 0
 
     sleep 2.5
-    counter.should.equal(2)
+    counter.should == 2
   end
 
-  #it 'should honour :dont_reschedule' do
+  #it 'honours :dont_reschedule' do
   #  stack = []
   #  @s.every 0.400 do |job|
   #    if stack.size > 3
@@ -136,7 +136,7 @@ describe "#{SCHEDULER_CLASS}#every" do
   #  stack.should.equal(%w[ ok ok ok ok done ])
   #end
 
-  it 'should accept job.unschedule within the job' do
+  it 'accepts job.unschedule within the job' do
 
     stack = []
 
@@ -151,11 +151,11 @@ describe "#{SCHEDULER_CLASS}#every" do
 
     sleep 4
 
-    @s.jobs.size.should.equal(0)
-    stack.should.equal(%w[ ok ok ok ok done ])
+    @s.jobs.size.should == 0
+    stack.should == %w[ ok ok ok ok done ]
   end
 
-  it 'should respect :blocking => true' do
+  it 'respects :blocking => true' do
 
     stack = []
 
@@ -166,28 +166,66 @@ describe "#{SCHEDULER_CLASS}#every" do
 
     sleep 5
 
-    stack.should.equal(%w[ ok ok ])
+    stack.should == %w[ ok ok ]
   end
 
+  it 'lists the "trigger threads"' do
+
+    @s.every '1s' do
+      sleep 10
+    end
+    sleep 5
+
+    @s.trigger_threads.size.should == 4
+  end
 end
 
 describe Rufus::Scheduler::EveryJob do
 
-  before do
+  before(:each) do
     @s = start_scheduler
   end
-  after do
+  after(:each) do
     stop_scheduler(@s)
   end
 
-  it 'should respond to #next_time' do
+  it 'responds to #next_time' do
 
     t = Time.now + 3 * 3600
 
     job = @s.every '3h' do
     end
 
-    job.next_time.to_i.should.equal(t.to_i)
+    job.next_time.to_i.should == t.to_i
+  end
+
+
+  it 'does not allow a job to overlap execution if set !allow_overlapping' do
+
+    stack = []
+
+    @s.every '1s', :allow_overlapping => false do |job|
+      stack << 'ok'
+      sleep 2
+    end
+
+    sleep 5
+
+    stack.size.should == 2
+  end
+
+  it 'allows a job to overlap execution (backward compatibility?)' do
+
+    stack = []
+
+    @s.every '1s' do |job|
+      stack << 'ok'
+      sleep 2
+    end
+
+    sleep 5
+
+    stack.size.should == 4
   end
 end