rufus-scheduler 2.0.24 → 3.0.0

data/spec/schedule_every_spec.rb

@@ -0,0 +1,109 @@
+
+#
+# Specifying rufus-scheduler
+#
+# Wed Apr 17 06:00:59 JST 2013
+#
+
+require 'spec_helper'
+
+
+describe Rufus::Scheduler do
+
+  before :each do
+    @scheduler = Rufus::Scheduler.new
+  end
+  after :each do
+    @scheduler.shutdown
+  end
+
+  describe '#every' do
+
+    it 'adds a job' do
+
+      @scheduler.every(10) do
+      end
+
+      @scheduler.jobs.size.should == 1
+      @scheduler.jobs.first.class.should == Rufus::Scheduler::EveryJob
+    end
+
+    it 'triggers a job (2 times)' do
+
+      counter = 0
+
+      @scheduler.every(0.4) do
+        counter += 1
+      end
+
+      sleep 2.0
+
+      counter.should > 2
+    end
+
+    it 'does not remove the job after execution' do
+
+      @scheduler.every(0.4) do
+      end
+
+      sleep 0.9
+
+      @scheduler.jobs.size.should == 1
+    end
+
+    it 'raises on negative frequencies' do
+
+      lambda {
+        @scheduler.every(-1) do
+        end
+      }.should raise_error(ArgumentError)
+    end
+
+    it 'raises on zero frequencies' do
+
+      lambda {
+        @scheduler.every(0) do
+        end
+      }.should raise_error(ArgumentError)
+    end
+
+    it 'does not reschedule if the job was unscheduled' do
+
+      counter = 0
+
+      job =
+        @scheduler.schedule_every '0.5s' do
+          counter = counter + 1
+        end
+
+      sleep 1.6
+
+      job.unschedule
+      c = counter
+
+      sleep 1.6
+
+      counter.should == c
+    end
+
+    it 'raises if the job frequency is higher than the scheduler frequency' do
+
+      @scheduler.frequency = 10
+
+      lambda {
+        @scheduler.every '1s' do; end
+      }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe '#schedule_every' do
+
+    it 'accepts a duration string' do
+
+      job = @scheduler.schedule_every('1h') do; end
+
+      job.frequency.should == 3600.0
+    end
+  end
+end
+

data/spec/schedule_in_spec.rb

@@ -0,0 +1,80 @@
+
+#
+# Specifying rufus-scheduler
+#
+# Wed Apr 17 06:00:59 JST 2013
+#
+
+require 'spec_helper'
+
+
+describe Rufus::Scheduler do
+
+  before :each do
+    @scheduler = Rufus::Scheduler.new
+  end
+  after :each do
+    @scheduler.shutdown
+  end
+
+  describe '#in' do
+
+    it 'adds a job' do
+
+      @scheduler.in(3600) do
+      end
+
+      @scheduler.jobs.size.should == 1
+      @scheduler.jobs.first.class.should == Rufus::Scheduler::InJob
+    end
+
+    it 'triggers a job' do
+
+      a = false
+
+      @scheduler.in(0.4) do
+        a = true
+      end
+
+      sleep 0.9
+
+      a.should == true
+    end
+
+    it 'removes the job after execution' do
+
+      @scheduler.in(0.4) do
+      end
+
+      sleep 0.700
+
+      @scheduler.jobs.size.should == 0
+    end
+  end
+
+  describe '#schedule_in' do
+
+    it 'accepts a number' do
+
+      job = @scheduler.schedule_in(3600) {}
+
+      job.original.should == 3600
+    end
+
+    it 'accepts a duration string' do
+
+      job = @scheduler.schedule_in('1h') {}
+
+      job.original.should == '1h'
+      job.time.should >= job.scheduled_at + 3509
+      job.time.should <= job.scheduled_at + 3601
+    end
+
+    it 'accepts an ActiveSupport .from_now thinggy'
+      #
+      #   schedule_in(2.days.from_now)
+      #
+      # that'd simply require "in" to be a bit like "at"...
+  end
+end
+

data/spec/schedule_interval_spec.rb

@@ -0,0 +1,128 @@
+
+#
+# Specifying rufus-scheduler
+#
+# Wed Aug  7 06:20:55 JST 2013
+#
+
+require 'spec_helper'
+
+
+describe Rufus::Scheduler do
+
+  before :each do
+    @scheduler = Rufus::Scheduler.new
+  end
+  after :each do
+    @scheduler.shutdown
+  end
+
+  describe '#interval' do
+
+    it 'adds a job' do
+
+      @scheduler.interval(10) do
+      end
+
+      @scheduler.jobs.size.should == 1
+      @scheduler.jobs.first.class.should == Rufus::Scheduler::IntervalJob
+    end
+
+    it 'triggers a job (2 times)' do
+
+      counter = 0
+
+      @scheduler.interval(0.4) do
+        counter += 1
+      end
+
+      sleep 2.0
+
+      counter.should > 2
+    end
+
+    it 'triggers, but reschedules after the trigger execution' do
+
+      chronos = []
+
+      @scheduler.interval(0.4) do
+        now = Time.now
+        last, delta = chronos.last
+        chronos << [ now, last ? now - last : nil ]
+        sleep 0.5
+      end
+
+      t = Time.now
+      sleep 0.1 while chronos.size < 4 && Time.now < t + 5
+
+      chronos.size.should == 4
+
+      deltas = chronos.collect(&:last).compact
+
+      #pp chronos
+      #pp deltas
+
+      deltas.each do |d|
+        d.should >= 0.9
+      end
+    end
+
+    it 'does not reschedule if the job was unscheduled' do
+
+      counter = 0
+
+      job =
+        @scheduler.schedule_interval '0.5s' do
+          counter = counter + 1
+        end
+
+      sleep 1.6
+
+      @scheduler.jobs(:all).size.should == 1
+
+      job.unschedule
+      c = counter
+
+      sleep 1.6
+
+      counter.should == c
+      @scheduler.jobs(:all).size.should == 0
+    end
+
+    it 'raises on negative intervals' do
+
+      lambda {
+        @scheduler.interval(-1) do
+        end
+      }.should raise_error(ArgumentError)
+    end
+
+    it 'raises on zero intervals' do
+
+      lambda {
+        @scheduler.interval(0) do
+        end
+      }.should raise_error(ArgumentError)
+    end
+
+    #it 'raises if the job frequency is higher than the scheduler frequency' do
+    #
+    #  @scheduler.frequency = 10
+    #
+    #  lambda {
+    #    @scheduler.interval '1s' do; end
+    #  }.should raise_error(ArgumentError)
+    #end
+  end
+
+  describe '#schedule_interval' do
+
+    it 'accepts a duration string' do
+
+      job = @scheduler.schedule_interval('1h') do; end
+
+      job.interval.should == 3600
+    end
+  end
+end
+

data/spec/scheduler_spec.rb

@@ -2,247 +2,954 @@
 #
 # Specifying rufus-scheduler
 #
-# Sat Mar 21 17:43:23 JST 2009
+# Wed Apr 17 06:00:59 JST 2013
 #
 
-require 'spec_base'
+require 'spec_helper'
 
 
-describe SCHEDULER_CLASS do
+describe Rufus::Scheduler do
 
-  it 'stops' do
+  describe '#initialize' do
 
-    var = nil
+    it 'starts the scheduler thread' do
 
-    s = start_scheduler
-    s.in('3s') { var = true }
+      scheduler = Rufus::Scheduler.new
 
-    stop_scheduler(s)
+      t = Thread.list.find { |t|
+        t[:name] == "rufus_scheduler_#{scheduler.object_id}_scheduler"
+      }
 
-    var.should == nil
-    sleep 4
-    var.should == nil
+      t[:rufus_scheduler].should == scheduler
+    end
+
+    it 'sets a :rufus_scheduler thread local var' do
+
+      scheduler = Rufus::Scheduler.new
+    end
+
+    it 'accepts a :frequency => integer option' do
+
+      scheduler = Rufus::Scheduler.new(:frequency => 2)
+
+      scheduler.frequency.should == 2
+    end
+
+    it 'accepts a :frequency => "2h1m" option' do
+
+      scheduler = Rufus::Scheduler.new(:frequency => '2h1m')
+
+      scheduler.frequency.should == 3600 * 2 + 60
+    end
+
+    it 'accepts a :thread_name option' do
+
+      scheduler = Rufus::Scheduler.new(:thread_name => 'oliphant')
+
+      t = Thread.list.find { |t| t[:name] == 'oliphant' }
+
+      t[:rufus_scheduler].should == scheduler
+    end
+
+    #it 'accepts a :min_work_threads option' do
+    #  scheduler = Rufus::Scheduler.new(:min_work_threads => 9)
+    #  scheduler.min_work_threads.should == 9
+    #end
+
+    it 'accepts a :max_work_threads option' do
+
+      scheduler = Rufus::Scheduler.new(:max_work_threads => 9)
+
+      scheduler.max_work_threads.should == 9
+    end
   end
 
-  unless SCHEDULER_CLASS == Rufus::Scheduler::EmScheduler
+  before :each do
+    @scheduler = Rufus::Scheduler.new
+  end
+  after :each do
+    @scheduler.shutdown
+  end
+
+  describe 'a schedule method' do
 
-    it 'sets a default scheduler thread name' do
+    it 'passes the job to its block when it triggers' do
 
-      s = start_scheduler
+      j = nil
+      job = @scheduler.schedule_in('0s') { |jj| j = jj }
+
+      sleep 0.4
+
+      j.should == job
+    end
 
-      s.instance_variable_get(:@thread)['name'].should match(
-        /Rufus::Scheduler::.*Scheduler - \d+\.\d+\.\d+/)
+    it 'passes the trigger time as second block argument' do
 
-      stop_scheduler(s)
+      t = nil
+      @scheduler.schedule_in('0s') { |jj, tt| t = tt }
+
+      sleep 0.4
+
+      t.class.should == Time
+    end
+
+    class MyHandler
+      attr_reader :counter
+      def initialize
+        @counter = 0
+      end
+      def call(job, time)
+        @counter = @counter + 1
+      end
     end
 
-    it 'sets the scheduler thread name' do
+    it 'accepts a callable object instead of a block' do
+
+      mh = MyHandler.new
+
+      @scheduler.schedule_in('0s', mh)
 
-      s = start_scheduler(:thread_name => 'nada')
-      s.instance_variable_get(:@thread)['name'].should == 'nada'
+      sleep 0.4
 
-      stop_scheduler(s)
+      mh.counter.should == 1
+    end
+
+    class MyOtherHandler
+      attr_reader :counter
+      def initialize
+        @counter = 0
+      end
+      def call
+        @counter = @counter + 1
+      end
+    end
+
+    it 'accepts a callable obj instead of a block (#call with no args)' do
+
+      job = @scheduler.schedule_in('0s', MyOtherHandler.new)
+
+      sleep 0.4
+
+      job.handler.counter.should == 1
+    end
+
+    it 'accepts a class as callable' do
+
+      job =
+        @scheduler.schedule_in('0s', Class.new do
+          attr_reader :value
+          def call
+            @value = 7
+          end
+        end)
+
+      sleep 0.4
+
+      job.handler.value.should == 7
+    end
+
+    it 'raises if the scheduler is shutting down' do
+
+      @scheduler.shutdown
+
+      lambda {
+        @scheduler.in('0s') { puts 'hhhhhhhhhhhello!!' }
+      }.should raise_error(RuntimeError)
     end
   end
 
-  it 'accepts a custom frequency' do
+  describe '#in / #at' do
+
+    # scheduler.in(2.hours.from_now) { ... }
 
-    var = nil
+    it 'accepts point in time and duration indifferently (#in)' do
 
-    s = start_scheduler(:frequency => 3.0)
+      seen = false
 
-    s.in('1s') { var = true }
+      t = Time.now + 1
 
-    sleep 1
-    var.should == nil
+      @scheduler.in(t) { seen = true }
 
-    sleep 1
-    var.should == nil
+      sleep 0.1 while seen != true
+    end
+
+    it 'accepts point in time and duration indifferently (#at)' do
+
+      seen = false
 
-    sleep 2
-    var.should == true
+      t = 1
 
-    stop_scheduler(s)
+      @scheduler.at(t) { seen = true }
+
+      sleep 0.1 while seen != true
+    end
   end
 
-  context 'pause/resume' do
+  describe '#schedule' do
 
-    before(:each) do
-      @s = start_scheduler
+    it 'accepts a duration and schedules an InJob' do
+
+      j = @scheduler.schedule '1s' do; end
+
+      j.class.should == Rufus::Scheduler::InJob
+      j.original.should == '1s'
     end
-    after(:each) do
-      stop_scheduler(@s)
+
+    it 'accepts a point in time and schedules an AtJob' do
+
+      j = @scheduler.schedule '2070/12/24 23:00' do; end
+
+      j.class.should == Rufus::Scheduler::AtJob
+      j.next_time.strftime('%Y %m %d').should == '2070 12 24'
     end
 
-    describe '#pause' do
+    it 'accepts a cron string and schedules a CronJob' do
+
+      j = @scheduler.schedule '* * * * *' do; end
+
+      j.class.should == Rufus::Scheduler::CronJob
+    end
+  end
+
+  describe '#repeat' do
+
+    it 'accepts a duration and schedules an EveryJob' do
+
+      j = @scheduler.repeat '1s' do; end
+
+      j.class.should == Rufus::Scheduler::EveryJob
+    end
+
+    it 'accepts a cron string and schedules a CronJob' do
+
+      j = @scheduler.repeat '* * * * *' do; end
+
+      j.class.should == Rufus::Scheduler::CronJob
+    end
+  end
+
+  describe '#unschedule(job_or_work_id)' do
+
+    it 'accepts job ids' do
+
+      job = @scheduler.schedule_in '10d' do; end
+
+      job.unscheduled_at.should == nil
+
+      @scheduler.unschedule(job.id)
+
+      job.unscheduled_at.should_not == nil
+    end
 
-      it 'pauses a job (every)' do
+    it 'accepts jobs' do
 
-        $count = 0
+      job = @scheduler.schedule_in '10d' do; end
 
-        j = @s.every '1s' do
-          $count = $count + 1
+      job.unscheduled_at.should == nil
+
+      @scheduler.unschedule(job)
+
+      job.unscheduled_at.should_not == nil
+    end
+
+    it 'carefully unschedules repeat jobs' do
+
+      counter = 0
+
+      job =
+        @scheduler.schedule_every '0.5s' do
+          counter = counter + 1
         end
 
-        @s.pause(j.job_id)
+      sleep 1.5
+      c = counter
+
+      @scheduler.unschedule(job)
+
+      sleep 1.5
+      counter.should == c
+    end
+  end
+
+  describe '#uptime' do
+
+    it 'returns the uptime as a float' do
+
+      @scheduler.uptime.should >= 0.0
+    end
+  end
+
+  describe '#uptime_s' do
+
+    it 'returns the uptime as a human readable string' do
+
+      sleep 1
+
+      @scheduler.uptime_s.should match(/^[12]s\d+$/)
+    end
+  end
+
+  describe '#join' do
+
+    it 'joins the scheduler thread' do
+
+      t = Thread.new { @scheduler.join; Thread.current['a'] = 'over' }
+
+      t['a'].should == nil
+
+      @scheduler.shutdown
+
+      sleep(1)
+
+      t['a'].should == 'over'
+    end
+  end
+
+  describe '#job(job_id)' do
+
+    it 'returns nil if there is no corresponding Job instance' do
+
+      @scheduler.job('nada').should == nil
+    end
+
+    it 'returns the corresponding Job instance' do
+
+      job_id = @scheduler.in '10d' do; end
+
+      sleep(1) # give it some time to get scheduled
+
+      @scheduler.job(job_id).job_id.should == job_id
+    end
+  end
+
+#    describe '#find_by_tag(t)' do
+#
+#      it 'returns an empty list when there are no jobs with the given tag' do
+#
+#        @scheduler.find_by_tag('nada').should == []
+#      end
+#
+#      it 'returns all the jobs with the given tag' do
+#
+#        @scheduler.in '10d', :tag => 't0' do; end
+#        @scheduler.every '2h', :tag => %w[ t0 t1 ] do; end
+#        @scheduler.every '3h' do; end
+#
+#        @scheduler.find_by_tag('t0').map(&:original).should ==
+#          %w[ 2h 10d ]
+#        @scheduler.find_by_tag('t1').map(&:original).should ==
+#          %w[ 2h ]
+#        @scheduler.find_by_tag('t1', 't0').map(&:original).sort.should ==
+#          %w[ 2h ]
+#      end
+#    end
+
+  describe '#threads' do
+
+    it 'just lists the main thread (scheduler thread) when no job is scheduled' do
 
-        sleep 2.5
+      @scheduler.threads.should == [ @scheduler.thread ]
+    end
 
-        j.paused?.should == true
-        $count.should == 0
+    it 'lists all the threads a scheduler uses' do
+
+      @scheduler.in '0s' do
+        sleep(2)
       end
 
-      it 'pauses a job (cron)' do
+      sleep 0.4
 
-        $count = 0
+      @scheduler.threads.size.should == 2
+    end
+  end
 
-        j = @s.cron '* * * * * *' do
-          $count = $count + 1
-        end
+  describe '#work_threads(:all)' do
+
+    it 'returns an empty array when the scheduler has not yet done anything' do
 
-        @s.pause(j.job_id)
+      @scheduler.work_threads.should == []
+    end
 
-        sleep 2.5
+    it 'lists all the work threads in the pool' do
 
-        j.paused?.should == true
-        $count.should == 0
+      @scheduler.in '0s' do
+        # nada
+      end
+      @scheduler.in '0s' do
+        sleep(2)
       end
+
+      sleep 0.6
+
+      @scheduler.work_threads.size.should == 2
     end
+  end
+
+  describe '#work_threads(:vacant)' do
 
-    describe '#resume' do
+    it 'returns an empty array when the scheduler has not yet done anything' do
 
-      it 'resumes a job (every)' do
+      @scheduler.work_threads(:vacant).should == []
+    end
+
+    it 'lists all the work threads in the pool' do
+
+      @scheduler.in '0s' do
+        # nada
+      end
+      @scheduler.in '0s' do
+        sleep(2)
+      end
 
-        $count = 0
+      sleep 0.4
 
-        j = @s.every '1s' do
-          $count = $count + 1
+      @scheduler.work_threads(:vacant).size.should == 1
+    end
+  end
+
+  describe '#work_threads(:active)' do
+
+    it 'returns [] when there are no jobs running' do
+
+      @scheduler.work_threads(:active).should == []
+    end
+
+    it 'returns the list of threads of the running jobs' do
+
+      job =
+        @scheduler.schedule_in('0s') do
+          sleep 1
         end
 
-        @s.pause(j.job_id)
+      sleep 0.4
 
-        sleep 2.5
+      @scheduler.work_threads(:active).size.should == 1
 
-        c = $count
+      t = @scheduler.work_threads(:active).first
 
-        @s.resume(j.job_id)
+      t.class.should == Thread
+      t[@scheduler.thread_key].should == true
+      t[:rufus_scheduler_job].should == job
+      t[:rufus_scheduler_time].should_not == nil
+    end
 
-        sleep 1.5
+    it 'does not return threads from other schedulers' do
 
-        j.paused?.should == false
-        ($count > c).should == true
-      end
+      scheduler = Rufus::Scheduler.new
 
-      it 'pauses a job (cron)' do
+      job =
+        @scheduler.schedule_in('0s') do
+          sleep(1)
+        end
 
-        $count = 0
+      sleep 0.4
+
+      scheduler.work_threads(:active).should == []
+
+      scheduler.shutdown
+    end
+  end
+
+  #describe '#min_work_threads' do
+  #  it 'returns the min job thread count' do
+  #    @scheduler.min_work_threads.should == 7
+  #  end
+  #end
+  #describe '#min_work_threads=' do
+  #  it 'sets the min job thread count' do
+  #    @scheduler.min_work_threads = 1
+  #    @scheduler.min_work_threads.should == 1
+  #  end
+  #end
+
+  describe '#max_work_threads' do
+
+    it 'returns the max job thread count' do
+
+      @scheduler.max_work_threads.should == 35
+    end
+  end
 
-        j = @s.cron '* * * * * *' do
-          $count = $count + 1
+  describe '#max_work_threads=' do
+
+    it 'sets the max job thread count' do
+
+      @scheduler.max_work_threads = 14
+
+      @scheduler.max_work_threads.should == 14
+    end
+  end
+
+  #describe '#kill_all_work_threads' do
+  #
+  #  it 'kills all the work threads' do
+  #
+  #    @scheduler.in '0s' do; sleep(5); end
+  #    @scheduler.in '0s' do; sleep(5); end
+  #    @scheduler.in '0s' do; sleep(5); end
+  #
+  #    sleep 0.5
+  #
+  #    @scheduler.work_threads.size.should == 3
+  #
+  #    @scheduler.send(:kill_all_work_threads)
+  #
+  #    sleep 0.5
+  #
+  #    @scheduler.work_threads.size.should == 0
+  #  end
+  #end
+
+  describe '#running_jobs' do
+
+    it 'returns [] when there are no running jobs' do
+
+      @scheduler.running_jobs.should == []
+    end
+
+    it 'returns a list of running Job instances' do
+
+      job =
+        @scheduler.schedule_in('0s') do
+          sleep(1)
         end
 
-        @s.pause(j.job_id)
+      sleep 0.4
+
+      job.running?.should == true
+      @scheduler.running_jobs.should == [ job ]
+    end
+
+    it 'does not return twice the same job' do
+
+      job =
+        @scheduler.schedule_every('0.3s') do
+          sleep(5)
+        end
 
-        sleep 2.5
+      sleep 1.5
 
-        c = $count
+      job.running?.should == true
+      @scheduler.running_jobs.should == [ job ]
+    end
+  end
 
-        @s.resume(j.job_id)
+  describe '#running_jobs(:tag/:tags => x)' do
 
-        sleep 1.5
+    it 'returns a list of running jobs filtered by tag' do
 
-        j.paused?.should == false
-        ($count > c).should == true
+      @scheduler.in '0.1s', :tag => 't0' do
+        sleep 3
+      end
+      @scheduler.in '0.2s', :tag => 't1' do
+        sleep 3
       end
+
+      sleep 0.4
+
+      @scheduler.running_jobs(:tag => 't0').map(&:original).should ==
+        %w[ 0.1s ]
+      @scheduler.running_jobs(:tag => 't1').map(&:original).should ==
+        %w[ 0.2s ]
+      @scheduler.running_jobs(:tags => %w[ t0 t1 ]).map(&:original).should ==
+        []
     end
   end
 
-  context 'trigger threads' do
+  #--
+  # management methods
+  #++
 
-    before(:each) do
-      @s = start_scheduler
+  describe '#shutdown' do
+
+    it 'blanks the uptime' do
+
+      @scheduler.shutdown
+
+      @scheduler.uptime.should == nil
     end
-    after(:each) do
-      stop_scheduler(@s)
+
+    it 'shuts the scheduler down' do
+
+      @scheduler.shutdown
+
+      sleep 0.100
+      sleep 0.400 if RUBY_VERSION < '1.9.0'
+
+      t = Thread.list.find { |t|
+        t[:name] == "rufus_scheduler_#{@scheduler.object_id}"
+      }
+
+      t.should == nil
     end
 
-    describe '#trigger_threads' do
+    it 'has a #stop alias' do
 
-      it 'returns an empty list when no jobs are running' do
+      @scheduler.stop
 
-        @s.trigger_threads.should == []
-      end
+      @scheduler.uptime.should == nil
+    end
 
-      it 'returns a list of the threads of the running jobs' do
+    #it 'has a #close alias'
+  end
 
-        @s.in('100') { sleep 10 }
+  describe '#shutdown(:wait)' do
 
-        sleep 0.5
+    it 'shuts down and blocks until all the jobs ended their current runs' do
 
-        @s.trigger_threads.collect { |e| e.class }.should == [ Thread ]
+      counter = 0
+
+      @scheduler.in '0s' do
+        sleep 1
+        counter = counter + 1
       end
+
+      sleep 0.4
+
+      @scheduler.shutdown(:wait)
+
+      counter.should == 1
+      @scheduler.uptime.should == nil
+      @scheduler.running_jobs.should == []
+      @scheduler.threads.should == []
     end
+  end
 
-    describe '#running_jobs' do
+  describe '#shutdown(:kill)' do
 
-      it 'returns an empty list when no jobs are running' do
+    it 'kills all the jobs and then shuts down' do
 
-        @s.running_jobs.should == []
+      counter = 0
+
+      @scheduler.in '0s' do
+        sleep 1
+        counter = counter + 1
+      end
+      @scheduler.at Time.now + 0.3 do
+        sleep 1
+        counter = counter + 1
       end
 
-      it 'returns a list of the currently running jobs' do
+      sleep 0.4
+
+      @scheduler.shutdown(:kill)
+
+      sleep 1.4
+
+      counter.should == 0
+      @scheduler.uptime.should == nil
+      @scheduler.running_jobs.should == []
+      @scheduler.threads.should == []
+    end
+  end
+
+  describe '#pause' do
+
+    it 'pauses the scheduler' do
+
+      job = @scheduler.schedule_in '1s' do; end
+
+      @scheduler.pause
+
+      sleep(3)
+
+      job.last_time.should == nil
+    end
+  end
+
+  describe '#resume' do
+
+    it 'works' do
+
+      job = @scheduler.schedule_in '2s' do; end
 
-        job = @s.in('100') { sleep 10 }
+      @scheduler.pause
+      sleep(1)
+      @scheduler.resume
+      sleep(2)
 
-        sleep 0.5
+      job.last_time.should_not == nil
+    end
+  end
+
+  describe '#paused?' do
+
+    it 'returns true if the scheduler is paused' do
+
+      @scheduler.pause
+      @scheduler.paused?.should == true
+    end
 
-        @s.running_jobs.should == [ job ]
+    it 'returns false if the scheduler is not paused' do
+
+      @scheduler.paused?.should == false
+
+      @scheduler.pause
+      @scheduler.resume
+
+      @scheduler.paused?.should == false
+    end
+  end
+
+  #--
+  # job methods
+  #++
+
+  describe '#jobs' do
+
+    it 'is empty at the beginning' do
+
+      @scheduler.jobs.should == []
+    end
+
+    it 'returns the list of scheduled jobs' do
+
+      @scheduler.in '10d' do; end
+      @scheduler.in '1w' do; end
+
+      sleep(1)
+
+      jobs = @scheduler.jobs
+
+      jobs.collect { |j| j.original }.sort.should == %w[ 10d 1w ]
+    end
+
+    it 'returns all the jobs (even those pending reschedule)' do
+
+      @scheduler.in '0s', :blocking => true do
+        sleep 2
       end
+
+      sleep 0.4
+
+      @scheduler.jobs.size.should == 1
+    end
+
+    it 'does not return unscheduled jobs' do
+
+      job =
+        @scheduler.schedule_in '0s', :blocking => true do
+          sleep 2
+        end
+
+      sleep 0.4
+
+      job.unschedule
+
+      @scheduler.jobs.size.should == 0
+    end
+  end
+
+  describe '#jobs(:tag / :tags => x)' do
+
+    it 'returns [] when there are no jobs with the corresponding tag' do
+
+      @scheduler.jobs(:tag => 'nada').should == []
+      @scheduler.jobs(:tags => %w[ nada hello ]).should == []
+    end
+
+    it 'returns the jobs with the corresponding tag' do
+
+      @scheduler.in '10d', :tag => 't0' do; end
+      @scheduler.every '2h', :tag => %w[ t0 t1 ] do; end
+      @scheduler.every '3h' do; end
+
+      @scheduler.jobs(:tags => 't0').map(&:original).sort.should ==
+        %w[ 10d 2h ]
+      @scheduler.jobs(:tags => 't1').map(&:original).sort.should ==
+        %w[ 2h ]
+      @scheduler.jobs(:tags => [ 't1', 't0' ]).map(&:original).sort.should ==
+        %w[ 2h ]
+    end
+  end
+
+  describe '#every_jobs' do
+
+    it 'returns EveryJob instances' do
+
+      @scheduler.at '2030/12/12 12:10:00' do; end
+      @scheduler.in '10d' do; end
+      @scheduler.every '5m' do; end
+
+      jobs = @scheduler.every_jobs
+
+      jobs.collect { |j| j.original }.sort.should == %w[ 5m ]
+    end
+  end
+
+  describe '#at_jobs' do
+
+    it 'returns AtJob instances' do
+
+      @scheduler.at '2030/12/12 12:10:00' do; end
+      @scheduler.in '10d' do; end
+      @scheduler.every '5m' do; end
+
+      jobs = @scheduler.at_jobs
+
+      jobs.collect { |j| j.original }.sort.should == [ '2030/12/12 12:10:00' ]
+    end
+  end
+
+  describe '#in_jobs' do
+
+    it 'returns InJob instances' do
+
+      @scheduler.at '2030/12/12 12:10:00' do; end
+      @scheduler.in '10d' do; end
+      @scheduler.every '5m' do; end
+
+      jobs = @scheduler.in_jobs
+
+      jobs.collect { |j| j.original }.sort.should == %w[ 10d ]
+    end
+  end
+
+  describe '#cron_jobs' do
+
+    it 'returns CronJob instances' do
+
+      @scheduler.at '2030/12/12 12:10:00' do; end
+      @scheduler.in '10d' do; end
+      @scheduler.every '5m' do; end
+      @scheduler.cron '* * * * *' do; end
+
+      jobs = @scheduler.cron_jobs
+
+      jobs.collect { |j| j.original }.sort.should == [ '* * * * *' ]
+    end
+  end
+
+  describe '#interval_jobs' do
+
+    it 'returns IntervalJob instances' do
+
+      @scheduler.at '2030/12/12 12:10:00' do; end
+      @scheduler.in '10d' do; end
+      @scheduler.every '5m' do; end
+      @scheduler.cron '* * * * *' do; end
+      @scheduler.interval '7m' do; end
+
+      jobs = @scheduler.interval_jobs
+
+      jobs.collect { |j| j.original }.sort.should == %w[ 7m ]
     end
   end
 
-  context 'termination' do
+  #--
+  # callbacks
+  #++
 
-    describe '#stop(true)' do
+  describe '#on_pre_trigger' do
 
-      it 'terminates the scheduler, blocking until all the jobs are unscheduled' do
+    it 'is called right before a job triggers' do
 
-        $every = nil
-        $cron = nil
+      $out = []
 
-        s = start_scheduler
-        s.every '1s' do
-          $every = :in
-          sleep 0.5
-          $every = :out
+      def @scheduler.on_pre_trigger(job)
+        $out << "pre #{job.id}"
+      end
+
+      job_id =
+        @scheduler.in '0.5s' do |job|
+          $out << job.id
         end
-        s.cron '* * * * * *' do
-          $cron = :in
-          sleep 0.5
-          $cron = :out
+
+      sleep 0.7
+
+      $out.should == [ "pre #{job_id}", job_id ]
+    end
+
+    it 'accepts the job and the triggerTime as argument' do
+
+      $tt = nil
+
+      def @scheduler.on_pre_trigger(job, trigger_time)
+        $tt = trigger_time
+      end
+
+      start = Time.now
+
+      @scheduler.in '0.5s' do; end
+
+      sleep 0.7
+
+      $tt.class.should == Time
+      $tt.should > start
+      $tt.should < Time.now
+    end
+
+    context 'when it returns false' do
+
+      it 'prevents the job from triggering' do
+
+        $out = []
+
+        def @scheduler.on_pre_trigger(job)
+          $out << "pre #{job.id}"
+          false
         end
 
-        sleep 2
+        job_id =
+          @scheduler.in '0.5s' do |job|
+            $out << job.id
+          end
 
-        s.stop(:terminate => true)
+        sleep 0.7
 
-        s.jobs.size.should == 0
-        $every.should == :out
-        $cron.should == :out
+        $out.should == [ "pre #{job_id}" ]
       end
     end
   end
-end
 
-describe 'Rufus::Scheduler#start_new' do
+  describe '#on_post_trigger' do
+
+    it 'is called right after a job triggers' do
+
+      $out = []
 
-  it 'piggybacks EM if present and running' do
+      def @scheduler.on_post_trigger(job)
+        $out << "post #{job.id}"
+      end
 
-    s = Rufus::Scheduler.start_new
+      job_id =
+        @scheduler.in '0.5s' do |job|
+          $out << job.id
+        end
 
-    s.class.should == SCHEDULER_CLASS
+      sleep 0.7
 
-    stop_scheduler(s)
+      $out.should == [ job_id, "post #{job_id}" ]
+    end
+  end
+
+  #--
+  # misc
+  #++
+
+  describe '.singleton / .s' do
+
+    before(:each) do
+
+      Rufus::Scheduler.class_eval { @singleton = nil } # ;-)
+    end
+
+    it 'returns a singleton instance of the scheduler' do
+
+      s0 = Rufus::Scheduler.singleton
+      s1 = Rufus::Scheduler.s
+
+      s0.class.should == Rufus::Scheduler
+      s1.object_id.should == s0.object_id
+    end
+
+    it 'accepts initialization parameters' do
+
+      s = Rufus::Scheduler.singleton(:max_work_threads => 77)
+      s = Rufus::Scheduler.singleton(:max_work_threads => 42)
+
+      s.max_work_threads.should == 77
+    end
   end
 end