rufus-scheduler 2.0.6 → 2.0.7

data/spec/scheduler_spec.rb

@@ -5,12 +5,12 @@
 # Sat Mar 21 17:43:23 JST 2009
 #
 
-require File.dirname(__FILE__) + '/spec_base'
+require File.join(File.dirname(__FILE__), 'spec_base')
 
 
 describe SCHEDULER_CLASS do
 
-  it 'should stop' do
+  it 'stops' do
 
     var = nil
 
@@ -19,33 +19,33 @@ describe SCHEDULER_CLASS do
 
     stop_scheduler(s)
 
-    var.should.be.nil
+    var.should == nil
     sleep 4
-    var.should.be.nil
+    var.should == nil
   end
 
   unless SCHEDULER_CLASS == Rufus::Scheduler::EmScheduler
 
-    it 'should set a default scheduler thread name' do
+    it 'sets a default scheduler thread name' do
 
       s = start_scheduler
 
-      s.instance_variable_get(:@thread)['name'].should.match(
+      s.instance_variable_get(:@thread)['name'].should match(
         /Rufus::Scheduler::.*Scheduler - \d+\.\d+\.\d+/)
 
       stop_scheduler(s)
     end
 
-    it 'should set the scheduler thread name' do
+    it 'sets the scheduler thread name' do
 
       s = start_scheduler(:thread_name => 'nada')
-      s.instance_variable_get(:@thread)['name'].should.equal('nada')
+      s.instance_variable_get(:@thread)['name'].should == 'nada'
 
       stop_scheduler(s)
     end
   end
 
-  it 'should accept a custom frequency' do
+  it 'accepts a custom frequency' do
 
     var = nil
 
@@ -54,26 +54,25 @@ describe SCHEDULER_CLASS do
     s.in('1s') { var = true }
 
     sleep 1
-    var.should.be.nil
+    var.should == nil
 
     sleep 1
-    var.should.be.nil
+    var.should == nil
 
     sleep 2
-    var.should.be.true
+    var.should == true
 
     stop_scheduler(s)
   end
-
 end
 
 describe 'Rufus::Scheduler#start_new' do
 
-  it 'should piggyback EM if present and running' do
+  it 'piggybacks EM if present and running' do
 
     s = Rufus::Scheduler.start_new
 
-    s.class.should.equal(SCHEDULER_CLASS)
+    s.class.should == SCHEDULER_CLASS
 
     stop_scheduler(s)
   end

data/spec/spec_base.rb

@@ -5,23 +5,16 @@
 # Fri Mar 20 22:53:33 JST 2009
 #
 
-
-#
-# bacon
-
 $:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')))
 
 require 'rubygems'
 require 'fileutils'
 
 
-$:.unshift(File.expand_path('~/tmp/bacon/lib')) # my own bacon for a while
-
-require 'bacon'
-
-puts
-
-Bacon.summary_on_exit
+#$:.unshift(File.expand_path('~/tmp/bacon/lib')) # my own bacon for a while
+#require 'bacon'
+#puts
+#Bacon.summary_on_exit
 
 
 #
@@ -59,11 +52,11 @@ SCHEDULER_CLASS = $plain ?
 #
 # helper methods
 
-def start_scheduler (opts={})
+def start_scheduler(opts={})
   SCHEDULER_CLASS.start_new(opts)
 end
 
-def stop_scheduler (s)
+def stop_scheduler(s)
   #s.stop(:stop_em => true)
   #sleep 0.200 # give time to the EM to stop
   s.stop

data/spec/stress_schedule_unschedule_spec.rb

@@ -1,155 +1,159 @@
 
-$LOAD_PATH << 'lib'
-require 'rufus/sc/scheduler'
+#
+# a spec by Klaas Jan Wierenga
+#
+
+require File.join(File.dirname(__FILE__), '/spec_base')
 
-require 'rubygems'
-require 'eventmachine'
 
-#require 'spec/autorun'
-require File.dirname(__FILE__) + '/spec_base'
 
 JOB_COUNT = 500 # 1000
 JOB_IDS = (1..JOB_COUNT).to_a
 NUM_RESCHEDULES = 5 # 10
 TRIGGER_DELAY = 4 # 15
 
+
 describe SCHEDULER_CLASS do
 
-# helper methods
+  # helper methods
+
+  # Wait for a variable to become a certain value.
+  # This method returns a block which loops waiting for the passed in
+  # block paramter to have value 'target'.
+  #
+  def eventually(timeout = TRIGGER_DELAY * 2, precision = 1)
+    lambda { |target|
+      value = nil
+      (timeout/precision).to_i.times do
+        value = yield # read variable once
+        # puts "got #{value}, expected #{target}"
+        break if target == value
+        sleep precision
+      end
+      target == value
+    }
+  end
 
-#
-# Wait for a variable to become a certain value.
-# This method returns a block which loops waiting for the passed in
-# block paramter to have value 'target'.
-#
-def eventually(timeout = TRIGGER_DELAY * 2, precision = 1)
-  lambda { |target|
-    value = nil
-    (timeout/precision).to_i.times do
-      value = yield # read variable once
-      # puts "got #{value}, expected #{target}"
-      break if target == value
-      sleep precision
+  def benchmark
+    now = Time.now
+    yield
+    benchmark = Time.now - now
+    print " (scheduling took #{benchmark}s)"
+    if benchmark > TRIGGER_DELAY
+      puts "\nTEST RESULT INVALID/UNRELIABLE"
+      puts "Scheduling took longer than TRIGGER_DELAY (#{TRIGGER_DELAY}s)."
+      puts "Increase TRIGGER_DELAY to a value larger than largest scheduling time."
     end
-    target == value
-  }
-end
-
-def benchmark
-  now = Time.now
-  yield
-  benchmark = Time.now - now
-  print " (scheduling took #{benchmark}s)"
-  if benchmark > TRIGGER_DELAY
-    puts "\nTEST RESULT INVALID/UNRELIABLE"
-    puts "Scheduling took longer than TRIGGER_DELAY (#{TRIGGER_DELAY}s)."
-    puts "Increase TRIGGER_DELAY to a value larger than largest scheduling time."
   end
-end
 
-def schedule_unschedule_same_ids_spec (mode)
-  scheduler = SCHEDULER_CLASS.start_new
-  benchmark { schedule_unschedule(scheduler, mode, NUM_RESCHEDULES) }
-  JOB_COUNT.should.satisfy &eventually { scheduler.all_jobs.size }
-  JOB_IDS.sort.should.equal(scheduler.find_jobs.map{ |job| job.job_id }.sort)
-  JOB_COUNT.should.satisfy &eventually { @trigger_queue.size }
-  @trigger_queue.size.should.equal(JOB_COUNT)
-  scheduler.stop
-end
+  def schedule_unschedule_same_ids_spec(mode)
+    scheduler = SCHEDULER_CLASS.start_new
+    benchmark { schedule_unschedule(scheduler, mode, NUM_RESCHEDULES) }
+    JOB_COUNT.should satisfy &eventually { scheduler.all_jobs.size }
+    JOB_IDS.sort.should == scheduler.find_jobs.map{ |job| job.job_id }.sort
+    JOB_COUNT.should satisfy &eventually { @trigger_queue.size }
+    @trigger_queue.size.should == JOB_COUNT
+    scheduler.stop
+  end
 
-def schedule_unschedule_unique_ids_spec (mode)
-  scheduler = SCHEDULER_CLASS.start_new
-  job_ids = []
-  benchmark { job_ids = schedule_unschedule(scheduler, mode, NUM_RESCHEDULES, true) }
-  JOB_COUNT.should.satisfy &eventually { scheduler.all_jobs.size }
-  job_ids.sort.should.equal(scheduler.find_jobs.map{ |job| job.job_id }.sort)
-  JOB_COUNT.should.satisfy &eventually { @trigger_queue.size }
-  @trigger_queue.size.should.equal(JOB_COUNT)
-  scheduler.stop
-end
+  def schedule_unschedule_unique_ids_spec(mode)
+    scheduler = SCHEDULER_CLASS.start_new
+    job_ids = []
+    benchmark { job_ids = schedule_unschedule(scheduler, mode, NUM_RESCHEDULES, true) }
+    JOB_COUNT.should satisfy &eventually { scheduler.all_jobs.size }
+    job_ids.sort.should == scheduler.find_jobs.map{ |job| job.job_id }.sort
+    JOB_COUNT.should satisfy &eventually { @trigger_queue.size }
+    @trigger_queue.size.should == JOB_COUNT
+    scheduler.stop
+  end
 
-def scheduler_counts(scheduler)
-  "all:%d at:%d cron:%d every:%d pending:%d" % [
-    scheduler.all_jobs.size,
-    scheduler.at_job_count,
-    scheduler.cron_job_count,
-    scheduler.every_job_count,
-    scheduler.pending_job_count]
-end
+  def scheduler_counts(scheduler)
+    "all:%d at:%d cron:%d every:%d pending:%d" % [
+      scheduler.all_jobs.size,
+      scheduler.at_job_count,
+      scheduler.cron_job_count,
+      scheduler.every_job_count,
+      scheduler.pending_job_count ]
+  end
 
-def schedule_unschedule(scheduler, mode, num_reschedules, generate_ids = false)
-  job_ids = schedule_jobs(scheduler, mode, generate_ids)
-  1.upto(num_reschedules) do
-    unschedule_jobs(scheduler, job_ids)
+  def schedule_unschedule(scheduler, mode, num_reschedules, generate_ids=false)
     job_ids = schedule_jobs(scheduler, mode, generate_ids)
+    1.upto(num_reschedules) do
+      unschedule_jobs(scheduler, job_ids)
+      job_ids = schedule_jobs(scheduler, mode, generate_ids)
+    end
+    job_ids
   end
-  job_ids
-end
 
-def schedule_jobs(scheduler, mode, generate_ids = false)
-  job_ids = []
-  JOB_IDS.each do |job_id|
-    case mode
-    when :cron
-      job_ids << scheduler.cron("%d * * * * *" % @cron_trigger,
-                                { :job_id => (generate_ids ? nil : job_id) },
-                                &@trigger_proc).job_id
-    when :at
-      job_ids << scheduler.at(@at_trigger,
-                              { :job_id => (generate_ids ? nil : job_id) },
-                              &@trigger_proc).job_id
-    when :every
-      job_ids << scheduler.every(@every_trigger,
-                                 { :job_id => (generate_ids ? nil : job_id) },
-                                 &@trigger_proc).job_id
-    else
-      raise ArgumentError
+  def schedule_jobs(scheduler, mode, generate_ids=false)
+    job_ids = []
+    JOB_IDS.each do |job_id|
+      case mode
+      when :cron
+        job_ids << scheduler.cron(
+          "%d * * * * *" % @cron_trigger,
+          { :job_id => (generate_ids ? nil : job_id) },
+          &@trigger_proc
+        ).job_id
+      when :at
+        job_ids << scheduler.at(
+          @at_trigger,
+          { :job_id => (generate_ids ? nil : job_id) },
+          &@trigger_proc
+        ).job_id
+      when :every
+        job_ids << scheduler.every(
+          @every_trigger,
+          { :job_id => (generate_ids ? nil : job_id) },
+          &@trigger_proc
+        ).job_id
+      else
+        raise ArgumentError
+      end
     end
+    job_ids
   end
-  job_ids
-end
 
-def unschedule_jobs(scheduler, job_ids)
-  job_ids.each { |job_id| scheduler.unschedule(job_id) }
-end
+  def unschedule_jobs(scheduler, job_ids)
+    job_ids.each { |job_id| scheduler.unschedule(job_id) }
+  end
 
-# the actual tests
+  # the actual tests
 
-before do #(:each) do
-  @trigger_queue = Queue.new
-  @cron_trigger = ((Time.now.to_i%60) + TRIGGER_DELAY) % 60 # 30 seconds from now
-  @at_trigger = Time.now + TRIGGER_DELAY
-  @every_trigger = "#{TRIGGER_DELAY}s"
-  @trigger_proc = lambda { |job| @trigger_queue << job.job_id }
-end
-
-after do #(:each) do
-  @trigger_queue = nil
-end
+  before(:each) do
+    @trigger_queue = Queue.new
+    @cron_trigger = ((Time.now.to_i%60) + TRIGGER_DELAY) % 60 # 30 seconds from now
+    @at_trigger = Time.now + TRIGGER_DELAY
+    @every_trigger = "#{TRIGGER_DELAY}s"
+    @trigger_proc = lambda { |job| @trigger_queue << job.job_id }
+  end
 
-it "should sustain frequent schedule/unschedule 'cron' jobs with same ids" do
-  schedule_unschedule_same_ids_spec(:cron)
-end
+  after(:each) do
+    @trigger_queue = nil
+  end
 
-it "should sustain frequent schedule/unschedule 'at' jobs with same ids" do
-  schedule_unschedule_same_ids_spec(:at)
-end
+  it "sustains frequent schedule/unschedule 'cron' jobs with same ids" do
+    schedule_unschedule_same_ids_spec(:cron)
+  end
 
-it "should sustain frequent schedule/unschedule 'every' jobs same ids" do
-  schedule_unschedule_same_ids_spec(:every)
-end
+  it "sustains frequent schedule/unschedule 'at' jobs with same ids" do
+    schedule_unschedule_same_ids_spec(:at)
+  end
 
-it "should sustain frequent schedule/unschedule 'cron' jobs with unique ids" do
-  schedule_unschedule_unique_ids_spec(:cron)
-end
+  it "sustains frequent schedule/unschedule 'every' jobs same ids" do
+    schedule_unschedule_same_ids_spec(:every)
+  end
 
-it "should sustain frequent schedule/unschedule 'at' jobs with unique ids" do
-  schedule_unschedule_unique_ids_spec(:at)
-end
+  it "sustains frequent schedule/unschedule 'cron' jobs with unique ids" do
+    schedule_unschedule_unique_ids_spec(:cron)
+  end
 
-it "should sustain frequent schedule/unschedule 'every' jobs unique ids" do
-  schedule_unschedule_unique_ids_spec(:every)
-end
+  it "sustains frequent schedule/unschedule 'at' jobs with unique ids" do
+    schedule_unschedule_unique_ids_spec(:at)
+  end
 
+  it "sustains frequent schedule/unschedule 'every' jobs unique ids" do
+    schedule_unschedule_unique_ids_spec(:every)
+  end
 end
 

data/spec/timeout_spec.rb

@@ -5,42 +5,42 @@
 # Sun May  3 15:44:28 JST 2009
 #
 
-require File.dirname(__FILE__) + '/spec_base'
+require File.join(File.dirname(__FILE__), '/spec_base')
 
 
 describe "#{SCHEDULER_CLASS} timeouts" do
 
-  before do
+  before(:each) do
     @s = start_scheduler
   end
-  after do
+  after(:each) do
     stop_scheduler(@s)
   end
 
-  it 'should should refuse to schedule a job with :timeout and :blocking' do
+  it 'refuses to schedule a job with :timeout and :blocking' do
 
     lambda {
       @s.in '1s', :timeout => '3s', :blocking => true do
       end
-    }.should.raise(ArgumentError)
+    }.should raise_error(ArgumentError)
   end
 
-  it 'should schedule a dedicated job for the timeout' do
+  it 'schedules a dedicated job for the timeout' do
 
     @s.in '1s', :timeout => '3s' do
       sleep 5
     end
 
-    @s.jobs.size.should.equal(1)
+    @s.jobs.size.should == 1
 
     # the timeout job is left
 
     sleep 2
-    @s.jobs.size.should.equal(1)
-    @s.find_by_tag('timeout').size.should.equal(1)
+    @s.jobs.size.should == 1
+    @s.find_by_tag('timeout').size.should == 1
   end
 
-  it 'should time out' do
+  it 'times out' do
 
     var = nil
     timedout = false
@@ -56,12 +56,12 @@ describe "#{SCHEDULER_CLASS} timeouts" do
 
     sleep 4
 
-    var.should.be.nil
-    @s.jobs.size.should.equal(0)
-    timedout.should.be.true
+    var.should == nil
+    @s.jobs.size.should == 0
+    timedout.should == true
   end
 
-  it 'should die silently if job finished before timeout' do
+  it 'dies silently if job finished before timeout' do
 
     var = nil
     timedout = false
@@ -76,12 +76,12 @@ describe "#{SCHEDULER_CLASS} timeouts" do
 
     sleep 3
 
-    var.should.be.true
-    @s.jobs.size.should.equal(0)
-    timedout.should.be.false
+    var.should == true
+    @s.jobs.size.should == 0
+    timedout.should == false
   end
 
-  it 'should not timeout other jobs (in case of every)' do
+  it 'does not timeout other jobs (in case of every)' do
 
     timeouts = []
 
@@ -96,11 +96,11 @@ describe "#{SCHEDULER_CLASS} timeouts" do
 
     sleep 5
 
-    timeouts.size.should.equal(3)
-    timeouts.each { |to| (to * 10).to_i.should.equal(16) }
+    timeouts.size.should == 3
+    timeouts.each { |to| (to * 10).to_i.should == 16 }
   end
 
-  it 'should point to their "parent" job' do
+  it 'points to their "parent" job' do
 
     @s.in '1s', :timeout => '3s', :job_id => 'nada' do
       sleep 4
@@ -108,10 +108,10 @@ describe "#{SCHEDULER_CLASS} timeouts" do
 
     sleep 2
 
-    @s.jobs.values.first.parent.job_id.should.equal('nada')
+    @s.jobs.values.first.parent.job_id.should == 'nada'
   end
 
-  it 'should not survive their job' do
+  it 'does not survive their job' do
 
     @s.in '1s', :timeout => '3s' do
       sleep 0.100
@@ -119,7 +119,7 @@ describe "#{SCHEDULER_CLASS} timeouts" do
 
     sleep 2
 
-    @s.jobs.size.should.equal(0)
+    @s.jobs.size.should == 0
   end
 end