rufus-scheduler 2.0.24 → 3.0.0

data/spec/schedulable_spec.rb

@@ -1,97 +0,0 @@
-
-#
-# Specifying rufus-scheduler
-#
-# Tue May  5 14:47:16 JST 2009
-#
-
-require 'spec_base'
-
-
-describe Rufus::Scheduler::Schedulable do
-
-  before(:each) do
-    @s = start_scheduler
-  end
-  after(:each) do
-    stop_scheduler(@s)
-  end
-
-  class JobAlpha
-    attr_reader :value
-    def trigger(params)
-      @value = params
-    end
-  end
-  class JobBravo
-    attr_reader :value
-    def call(job)
-      @value = job
-    end
-  end
-
-  it 'schedules via :schedulable' do
-
-    j = JobAlpha.new
-
-    @s.in '1s', :schedulable => j
-
-    sleep 1.4
-
-    j.value.class.should == Hash
-    j.value[:job].class.should == Rufus::Scheduler::InJob
-  end
-
-  it 'honours schedulables that reply to :call' do
-
-    j = JobBravo.new
-
-    @s.in '1s', :schedulable => j
-
-    sleep 1.4
-
-    j.value.class.should == Rufus::Scheduler::InJob
-  end
-
-  it 'accepts trigger schedulables as second param' do
-
-    j = JobAlpha.new
-
-    @s.in '1s', j
-
-    sleep 1.4
-
-    j.value.class.should == Hash
-    j.value[:job].class.should == Rufus::Scheduler::InJob
-  end
-
-  it 'accepts call schedulables as second param' do
-
-    j = JobBravo.new
-
-    @s.in '1s', j
-
-    sleep 1.4
-
-    j.value.class.should == Rufus::Scheduler::InJob
-  end
-
-  class MySchedulable
-    def self.job
-      @@job
-    end
-    def self.call(job)
-      @@job = job
-    end
-  end
-
-  it 'accepts schedulable classes as second param' do
-
-    @s.in '1s', MySchedulable
-
-    sleep 1.4
-
-    MySchedulable.job.class.should == Rufus::Scheduler::InJob
-  end
-end
-

data/spec/spec_base.rb

@@ -1,87 +0,0 @@
-
-#
-# Specifying rufus-scheduler
-#
-# Fri Mar 20 22:53:33 JST 2009
-#
-
-$:.unshift(File.expand_path('../../lib', __FILE__))
-
-require 'rubygems'
-require 'fileutils'
-
-
-Thread.abort_on_exception = true
-
-
-#$:.unshift(File.expand_path('~/tmp/bacon/lib')) # my own bacon for a while
-#require 'bacon'
-#puts
-#Bacon.summary_on_exit
-
-
-#
-# rufus/scheduler/em
-
-# EM or plain ?
-
-$plain = ! ENV['EVENTMACHINE']
-
-require 'rufus/scheduler'
-
-if ( ! $plain)
-
-  require 'eventmachine'
-
-  unless (EM.reactor_running?)
-
-    Thread.new { EM.run { } }
-
-    sleep 0.200
-    while (not EM.reactor_running?)
-      Thread.pass
-    end
-      #
-      # all this waiting, especially for the JRuby eventmachine, which seems
-      # rather 'diesel'
-
-  end
-end
-
-SCHEDULER_CLASS = $plain ?
-  Rufus::Scheduler::PlainScheduler :
-  Rufus::Scheduler::EmScheduler
-
-#
-# helper methods
-
-def start_scheduler(opts={})
-  SCHEDULER_CLASS.start_new(opts)
-end
-
-def stop_scheduler(s)
-  #s.stop(:stop_em => true)
-  #sleep 0.200 # give time to the EM to stop
-  s.stop
-  sleep 0.200
-end
-
-def wait_next_tick
-  #if defined?(EM)
-  #  t = Thread.current
-  #  EM.next_tick { t.wakeup }
-  #  Thread.stop
-  #else
-  sleep 0.500
-  #end
-end
-
-def local(*args)
-  Time.local(*args)
-end
-alias lo local
-
-def utc(*args)
-  Time.utc(*args)
-end
-

data/spec/stress_schedule_unschedule_spec.rb

@@ -1,159 +0,0 @@
-
-#
-# a spec by Klaas Jan Wierenga
-#
-
-require '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
-
-  # 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
-
-  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 == 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 == 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 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
-
-  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
-
-  def unschedule_jobs(scheduler, job_ids)
-    job_ids.each { |job_id| scheduler.unschedule(job_id) }
-  end
-
-  # the actual tests
-
-  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
-
-  after(:each) do
-    @trigger_queue = nil
-  end
-
-  it "sustains frequent schedule/unschedule 'cron' jobs with same ids" do
-    schedule_unschedule_same_ids_spec(:cron)
-  end
-
-  it "sustains frequent schedule/unschedule 'at' jobs with same ids" do
-    schedule_unschedule_same_ids_spec(:at)
-  end
-
-  it "sustains frequent schedule/unschedule 'every' jobs same ids" do
-    schedule_unschedule_same_ids_spec(:every)
-  end
-
-  it "sustains frequent schedule/unschedule 'cron' jobs with unique ids" do
-    schedule_unschedule_unique_ids_spec(:cron)
-  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

@@ -1,148 +0,0 @@
-
-#
-# Specifying rufus-scheduler
-#
-# Sun May  3 15:44:28 JST 2009
-#
-
-require 'spec_base'
-
-
-describe "#{SCHEDULER_CLASS} timeouts" do
-
-  before(:each) do
-    @s = start_scheduler
-  end
-  after(:each) do
-    stop_scheduler(@s)
-  end
-
-  it 'refuses to schedule a job with :timeout and :blocking' do
-
-    lambda {
-      @s.in '1s', :timeout => '3s', :blocking => true do
-      end
-    }.should raise_error(ArgumentError)
-  end
-
-  it 'schedules a dedicated job for the timeout' do
-
-    @s.in '1s', :timeout => '3s' do
-      sleep 5
-    end
-
-    @s.jobs.size.should == 1
-
-    # the timeout job is left
-
-    sleep 2
-    @s.jobs.size.should == 1
-    @s.find_by_tag('timeout').size.should == 1
-  end
-
-  it 'times out' do
-
-    var = nil
-    timedout = false
-
-    @s.in '1s', :timeout => '1s' do
-      begin
-        sleep 2
-        var = true
-      rescue Rufus::Scheduler::TimeOutError => e
-        timedout = true
-      end
-    end
-
-    sleep 4
-
-    var.should == nil
-    @s.jobs.size.should == 0
-    timedout.should == true
-  end
-
-  it 'dies silently if job finished before timeout' do
-
-    var = nil
-    timedout = false
-
-    @s.in '1s', :timeout => '1s' do
-      begin
-        var = true
-      rescue Rufus::Scheduler::TimeOutError => e
-        timedout = true
-      end
-    end
-
-    sleep 3
-
-    var.should == true
-    @s.jobs.size.should == 0
-    timedout.should == false
-  end
-
-  it 'does not timeout other jobs (in case of every)' do
-
-    timeouts = []
-
-    @s.every '1s', :timeout => '1s500' do
-      start = Time.now
-      begin
-        sleep 2.0
-      rescue Rufus::Scheduler::TimeOutError => e
-        timeouts << (Time.now - start)
-      end
-    end
-
-    sleep 5.5
-
-    timeouts.size.should == 3
-    timeouts.each { |to| to.should be_within(0.5).of(1.5) }
-  end
-
-  it 'points to their "parent" job' do
-
-    @s.in '1s', :timeout => '3s', :job_id => 'nada' do
-      sleep 4
-    end
-
-    sleep 2
-
-    @s.jobs.values.first.parent.job_id.should == 'nada'
-  end
-
-  it 'does not survive their job' do
-
-    @s.in '1s', :timeout => '3s' do
-      sleep 0.100
-    end
-
-    sleep 2
-
-    @s.jobs.size.should == 0
-  end
-
-  it 'times out properly after waiting for a mutex' do
-
-    mutex = Mutex.new
-    timedout = false
-
-    @s.in '0s', :mutex => mutex do
-      sleep 1
-    end
-
-    @s.in '0s', :mutex => mutex, :timeout => 0.1 do
-      begin
-        sleep 2
-      rescue Rufus::Scheduler::TimeOutError => e
-        timedout = true
-      end
-    end
-
-    sleep 2
-
-    @s.jobs.size.should == 0
-    timedout.should be_true
-  end
-end
-