rufus-scheduler 2.0.24 → 3.0.0

data/spec/job_repeat_spec.rb

@@ -0,0 +1,308 @@
+
+#
+# Specifying rufus-scheduler
+#
+# Wed Apr 17 06:00:59 JST 2013
+#
+
+require 'spec_helper'
+
+
+describe Rufus::Scheduler::RepeatJob do
+
+  before :each do
+    @scheduler = Rufus::Scheduler.new
+  end
+  after :each do
+    @scheduler.shutdown
+  end
+
+  describe '#pause' do
+
+    it 'pauses the job' do
+
+      counter = 0
+
+      job =
+        @scheduler.schedule_every('0.5s') do
+          counter += 1
+        end
+
+      counter.should == 0
+
+      while counter < 1; sleep(0.1); end
+
+      job.pause
+
+      sleep(1)
+
+      counter.should == 1
+    end
+  end
+
+  describe '#paused?' do
+
+    it 'returns true if the job is paused' do
+
+      job = @scheduler.schedule_every('10s') do; end
+
+      job.pause
+
+      job.paused?.should == true
+    end
+
+    it 'returns false if the job is not paused' do
+
+      job = @scheduler.schedule_every('10s') do; end
+
+      job.paused?.should == false
+    end
+  end
+
+  describe '#resume' do
+
+    it 'resumes a paused job' do
+
+      counter = 0
+
+      job =
+        @scheduler.schedule_every('0.5s') do
+          counter += 1
+        end
+
+      job.pause
+      job.resume
+
+      sleep(1.5)
+
+      counter.should > 1
+    end
+
+    it 'has no effect on a not paused job' do
+
+      job = @scheduler.schedule_every('10s') do; end
+
+      job.resume
+
+      job.paused?.should == false
+    end
+  end
+
+  describe ':times => i' do
+
+    it 'lets a job unschedule itself after i times' do
+
+      counter = 0
+
+      job =
+        @scheduler.schedule_every '0.5s', :times => 3 do
+          counter = counter + 1
+        end
+
+      sleep(2.6)
+
+      counter.should == 3
+    end
+
+    it 'is OK when passed a nil instead of an integer' do
+
+      counter = 0
+
+      job =
+        @scheduler.schedule_every '0.5s', :times => nil do
+          counter = counter + 1
+        end
+
+      sleep(2.5)
+
+      counter.should > 3
+    end
+
+    it 'raises when passed something else than nil or an integer' do
+
+      lambda {
+        @scheduler.schedule_every '0.5s', :times => 'nada' do; end
+      }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe ':first/:first_in/:first_at => point in time' do
+
+    it 'accepts a Time instance' do
+
+      t = Time.now + 10
+
+      job = @scheduler.schedule_every '0.5s', :first => t do; end
+
+      job.first_at.should == t
+    end
+
+    it 'accepts a time string' do
+
+      t = Time.now + 10
+
+      job = @scheduler.schedule_every '0.5s', :first => t.to_s do; end
+
+      job.first_at.to_s.should == t.to_s
+      job.first_at.zone.should == t.zone
+    end
+
+    it 'only lets the job trigger after the :first' do
+
+      t = Time.now + 1.4
+      counter = 0
+
+      job =
+        @scheduler.schedule_every '0.5s', :first => t do
+          counter = counter + 1
+        end
+
+      sleep(1)
+
+      counter.should == 0
+
+      sleep(1)
+
+      counter.should > 0
+    end
+
+    it 'raises on points in the past' do
+
+      lambda {
+
+        @scheduler.schedule_every '0.5s', :first => Time.now - 60 do; end
+
+      }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe ':first/:first_in/:first_at => duration' do
+
+    it 'accepts a duration string' do
+
+      t = Time.now
+
+      job = @scheduler.schedule_every '0.5s', :first => '1h' do; end
+
+      job.first_at.should >= t + 3600
+      job.first_at.should < t + 3601
+    end
+
+    it 'accepts a duration in seconds (integer)' do
+
+      t = Time.now
+
+      job = @scheduler.schedule_every '0.5s', :first => 3600 do; end
+
+      job.first_at.should >= t + 3600
+      job.first_at.should < t + 3601
+    end
+
+    it 'raises if the argument cannot be used' do
+
+      lambda {
+        @scheduler.every '0.5s', :first => :nada do; end
+      }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe '#first_at=' do
+
+    it 'can be used to set first_at directly' do
+
+      job = @scheduler.schedule_every '0.5s', :first => 3600 do; end
+      job.first_at = '2030-12-12 12:00:30'
+
+      job.first_at.strftime('%c').should == 'Thu Dec 12 12:00:30 2030'
+    end
+  end
+
+  describe ':last/:last_in/:last_at => point in time' do
+
+    it 'accepts a Time instance' do
+
+      t = Time.now + 10
+
+      job = @scheduler.schedule_every '0.5s', :last => t do; end
+
+      job.last_at.should == t
+    end
+
+    it 'unschedules the job after the last_at time' do
+
+      t = Time.now + 2
+      counter = 0
+
+      job =
+        @scheduler.schedule_every '0.5s', :last => t do
+          counter = counter + 1
+        end
+
+      sleep 3
+
+      counter.should == 3
+      @scheduler.jobs.should_not include(job)
+    end
+
+    it 'accepts a time string' do
+
+      t = Time.now + 10
+
+      job = @scheduler.schedule_every '0.5s', :last => t.to_s do; end
+
+      job.last_at.to_s.should == t.to_s
+      job.last_at.zone.should == t.zone
+    end
+
+    it 'raises on a point in the past' do
+
+      lambda {
+
+        @scheduler.every '0.5s', :last => Time.now - 60 do; end
+
+      }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe ':last/:last_in/:last_at => duration' do
+
+    it 'accepts a duration string' do
+
+      t = Time.now
+
+      job = @scheduler.schedule_every '0.5s', :last_in => '2s' do; end
+
+      job.last_at.should >= t + 2
+      job.last_at.should < t + 2.5
+    end
+
+    it 'accepts a duration in seconds (integer)' do
+
+      t = Time.now
+
+      job = @scheduler.schedule_every '0.5s', :last_in => 2.0 do; end
+
+      job.last_at.should >= t + 2
+      job.last_at.should < t + 2.5
+    end
+
+    it 'raises if the argument is worthless' do
+
+      lambda {
+        @scheduler.every '0.5s', :last => :nada do; end
+      }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe '#last_at=' do
+
+    it 'can be used to set last_at directly' do
+
+      job = @scheduler.schedule_every '0.5s', :last_in => 10.0 do; end
+      job.last_at = '2030-12-12 12:00:30'
+
+      job.last_at.strftime('%c').should == 'Thu Dec 12 12:00:30 2030'
+    end
+  end
+end
+

data/spec/job_spec.rb

@@ -2,240 +2,512 @@
 #
 # Specifying rufus-scheduler
 #
-# Wed Apr 27 00:51:07 JST 2011
+# Wed Apr 17 06:00:59 JST 2013
 #
 
-require 'spec_base'
+require 'spec_helper'
 
 
-describe 'job classes' do
+describe Rufus::Scheduler::Job do
 
-  before(:each) do
-    @s = start_scheduler
+  # specify behaviours common to all job classes
+
+  before :each do
+
+    @taoe = Thread.abort_on_exception
+    Thread.abort_on_exception = false
+
+    @ose = $stderr
+    $stderr = StringIO.new
+
+    @scheduler = Rufus::Scheduler.new
   end
-  after(:each) do
-    stop_scheduler(@s)
+
+  after :each do
+
+    @scheduler.shutdown
+
+    Thread.abort_on_exception = @taoe
+
+    $stderr = @ose
   end
 
-  describe Rufus::Scheduler::Job do
+  describe '#last_time' do
 
-    describe '#running' do
+    it 'returns nil if the job never fired' do
 
-      it 'returns false when the job is inactive' do
+      job = @scheduler.schedule_in '10d' do; end
 
-        job = @s.in '2d' do
-        end
+      job.last_time.should == nil
+    end
 
-        job.running.should == false
-      end
+    it 'returns the last time the job fired' do
 
-      it 'returns true when the job is active' do
+      job = @scheduler.schedule_in '0s' do; end
 
-        job = @s.in 0 do
-          sleep(100)
-        end
+      sleep 0.4
 
-        wait_next_tick
+      job.last_time.should_not == nil
+    end
+  end
 
-        job.running.should == true
-      end
+  describe '#threads' do
 
-      it 'returns false when the job hits some error' do
+    it 'returns an empty list when the job is not running' do
 
-        $exception = nil
+      job = @scheduler.in('1d', :job => true) {}
 
-        def @s.handle_exception(j, e)
-          #p e
-          $exception = e
-        end
+      job.threads.size.should == 0
+    end
 
-        job = @s.in 0 do
-          raise "nada"
+    it 'returns an empty list after the job terminated' do
+
+      job = @scheduler.in('0s', :job => true) {}
+
+      sleep 0.8
+
+      job.threads.size.should == 0
+    end
+
+    it 'lists the threads the job currently runs in' do
+
+      job =
+        @scheduler.schedule_in('0s') do
+          sleep(1)
         end
 
-        wait_next_tick
+      sleep 0.4
 
-        $exception.should_not == nil
-        job.running.should == false
-      end
+      job.threads.size.should == 1
+
+      t = job.threads.first
+      t[:rufus_scheduler_job].should == job
     end
+  end
 
-    describe '#running?' do
+  describe '#kill' do
 
-      it 'is an alias for #running' do
+    it 'has no effect if the job is not running' do
 
-        job = @s.in 0 do
-          sleep(100)
+      job = @scheduler.schedule_in '10d' do; end
+
+      tls = Thread.list.size
+
+      job.kill
+
+      Thread.list.size.should == tls
+    end
+
+    it 'makes the threads vacant' do
+
+      counter = 0
+
+      job =
+        @scheduler.schedule_in '0s' do
+          sleep 2
+          counter = counter + 1
         end
 
-        wait_next_tick
+      sleep 1
 
-        job.running?.should == true
-      end
+      v0 = @scheduler.work_threads(:vacant).size
+      a0 = @scheduler.work_threads(:active).size
+
+      job.kill
+
+      sleep 2
+
+      v1 = @scheduler.work_threads(:vacant).size
+      a1 = @scheduler.work_threads(:active).size
+
+      counter.should == 0
+
+      v0.should == 0
+      a0.should == 1
+
+      v1.should == 1
+      a1.should == 0
     end
   end
 
-  describe Rufus::Scheduler::AtJob do
+  describe '#running?' do
 
-    describe '#unschedule' do
+    it 'returns false when the job is not running in any thread' do
 
-      it 'removes the job from the scheduler' do
+      job = @scheduler.in('1d', :job => true) {}
 
-        job = @s.at Time.now + 3 * 3600 do
-        end
+      job.running?.should == false
+    end
 
-        wait_next_tick
+    it 'returns true when the job is running in at least one thread' do
 
-        job.unschedule
+      job = @scheduler.in('0s', :job => true) { sleep(1) }
 
-        @s.jobs.size.should == 0
-      end
+      sleep 0.4
+
+      job.running?.should == true
     end
+  end
 
-    describe '#next_time' do
+  describe '#scheduled?' do
 
-      it 'returns the time when the job will trigger' do
+    it 'returns true when the job is scheduled' do
 
-        t = Time.now + 3 * 3600
+      job = @scheduler.schedule_in('1d') {}
 
-        job = @s.at Time.now + 3 * 3600 do
-        end
+      job.scheduled?.should == true
+    end
 
-        job.next_time.class.should == Time
-        job.next_time.to_i.should == t.to_i
-      end
+    it 'returns false when the job is not scheduled' do
+
+      job = @scheduler.schedule_in('0.1s') {}
+
+      sleep 0.4
+
+      job.scheduled?.should == false
+    end
+
+    it 'returns true for repeat jobs that are running' do
+
+      job = @scheduler.schedule_interval('0.4s') { sleep(10) }
+
+      sleep 1
+
+      job.running?.should == true
+      job.scheduled?.should == true
     end
   end
 
-  describe Rufus::Scheduler::InJob do
+  context 'job-local variables' do
 
-    describe '#unschedule' do
+    describe '#[]=' do
 
-      it 'removes the job from the scheduler' do
+      it 'sets a job-local variable' do
 
-        job = @s.in '2d' do
-        end
+        job =
+          @scheduler.schedule_every '1s' do |job|
+            job[:counter] ||= 0
+            job[:counter] += 1
+          end
+
+        sleep 3
 
-        wait_next_tick
+        job[:counter].should > 1
+      end
+    end
 
-        job.unschedule
+    describe '#[]' do
 
-        @s.jobs.size.should == 0
+      it 'returns nil if there is no such entry' do
+
+        job = @scheduler.schedule_in '1s' do; end
+
+        job[:nada].should == nil
+      end
+
+      it 'returns the value of a job-local variable' do
+
+        job = @scheduler.schedule_in '1s' do; end
+        job[:x] = :y
+
+        job[:x].should == :y
       end
     end
 
-    describe '#next_time' do
+    describe '#key?' do
 
-      it 'returns the time when the job will trigger' do
+      it 'returns true if there is an entry with the given key' do
 
-        t = Time.now + 3 * 3600
+        job = @scheduler.schedule_in '1s' do; end
+        job[:x] = :y
 
-        job = @s.in '3h' do
-        end
+        job.key?(:x).should == true
+      end
+    end
+
+    describe '#keys' do
+
+      it 'returns the array of keys of the job-local variables' do
 
-        job.next_time.class.should == Time
-        job.next_time.to_i.should == t.to_i
+        job = @scheduler.schedule_in '1s' do; end
+        job[:x] = :y
+        job['hello'] = :z
+        job[123] = {}
+
+        job.keys.sort_by { |k| k.to_s }.should == [ 123, 'hello', :x ]
       end
     end
   end
 
-  describe Rufus::Scheduler::EveryJob do
+  context ':tag / :tags => [ t0, t1 ]' do
 
-    describe '#next_time' do
+    it 'accepts one tag' do
 
-      it 'returns the time when the job will trigger' do
+      job = @scheduler.in '10d', :job => true, :tag => 't0' do; end
 
-        t = Time.now + 3 * 3600
+      job.tags.should == %w[ t0 ]
+    end
+
+    it 'accepts an array of tags' do
+
+      job = @scheduler.in '10d', :job => true, :tag => %w[ t0 t1 ] do; end
+
+      job.tags.should == %w[ t0 t1 ]
+    end
 
-        job = @s.every '3h' do
+    it 'turns tags into strings' do
+
+      job = @scheduler.in '10d', :job => true, :tags => [ 1, 2 ] do; end
+
+      job.tags.should == %w[ 1 2 ]
+    end
+  end
+
+  context ':blocking => true' do
+
+    it 'runs the job in the same thread as the scheduler thread' do
+
+      job =
+        @scheduler.in('0s', :job => true, :blocking => true) do
+          sleep(1)
         end
 
-        job.next_time.class.should == Time
-        job.next_time.to_i.should == t.to_i
-      end
+      sleep 0.4
+
+      job.threads.first.should == @scheduler.thread
+
+      sleep 1.4
+
+      job.threads.size.should == 0
     end
+  end
 
-    describe '#paused?' do
+  context 'default one thread per job behaviour' do
 
-      it 'returns false initially' do
+    it 'runs the job in a dedicated thread' do
 
-        job = @s.every '3h' do; end
+      job =
+        @scheduler.in('0s', :job => true) do
+          sleep(1)
+        end
 
-        job.paused?.should == false
-      end
+      sleep 0.4
+
+      job.threads.first.should_not == @scheduler.thread
+
+      sleep 1.4
+
+      job.threads.size.should == 0
     end
+  end
+
+  context ':allow_overlapping / :allow_overlap / :overlap' do
 
-    describe '#pause' do
+    context 'default (:overlap => true)' do
 
-      it 'pauses the job' do
+      it 'lets a job overlap itself' do
 
-        job = @s.every '3h' do; end
+        job =
+          @scheduler.every('0.3', :job => true) do
+            sleep(5)
+          end
 
-        job.pause
+        sleep 3
 
-        job.paused?.should == true
+        job.threads.size.should > 1
       end
     end
 
-    describe '#resume' do
+    context 'when :overlap => false' do
 
-      it 'resumes the job' do
+      it 'prevents a job from overlapping itself' do
 
-        job = @s.every '3h' do; end
+        job =
+          @scheduler.every('0.3', :job => true, :overlap => false) do
+            sleep(5)
+          end
 
-        job.resume
+        sleep 3
 
-        job.paused?.should == false
+        job.threads.size.should == 1
       end
     end
   end
 
-  describe Rufus::Scheduler::CronJob do
+  context ':mutex' do
+
+    context ':mutex => "mutex_name"' do
+
+      it 'prevents concurrent executions' do
+
+        j0 =
+          @scheduler.in('0s', :job => true, :mutex => 'vladivostok') do
+            sleep(3)
+          end
+        j1 =
+          @scheduler.in('0s', :job => true, :mutex => 'vladivostok') do
+            sleep(3)
+          end
+
+        sleep 0.7
+
+        if j0.threads.any?
+          j0.threads.size.should == 1
+          j1.threads.size.should == 0
+        else
+          j0.threads.size.should == 0
+          j1.threads.size.should == 1
+        end
+
+        @scheduler.mutexes.keys.should == %w[ vladivostok ]
+      end
+    end
+
+    context ':mutex => mutex_instance' do
+
+      it 'prevents concurrent executions' do
 
-    describe '#next_time' do
+        m = Mutex.new
 
-      it 'returns the time when the job will trigger' do
+        j0 = @scheduler.in('0s', :job => true, :mutex => m) { sleep(3) }
+        j1 = @scheduler.in('0s', :job => true, :mutex => m) { sleep(3) }
 
-        job = @s.cron '* * * * *' do
+        sleep 0.7
+
+        if j0.threads.any?
+          j0.threads.size.should == 1
+          j1.threads.size.should == 0
+        else
+          j0.threads.size.should == 0
+          j1.threads.size.should == 1
         end
 
-        job.next_time.class.should == Time
-        (job.next_time.to_i - Time.now.to_i).should satisfy { |v| v < 60 }
+        @scheduler.mutexes.keys.should == []
       end
     end
 
-    describe '#paused?' do
+    context ':mutex => [ array_of_mutex_names_or_instances ]' do
+
+      it 'prevents concurrent executions' do
 
-      it 'returns false initially' do
+        j0 =
+          @scheduler.in('0s', :job => true, :mutex => %w[ a b ]) do
+            sleep(3)
+          end
+        j1 =
+          @scheduler.in('0s', :job => true, :mutex => %w[ a b ]) do
+            sleep(3)
+          end
 
-        job = @s.cron '* * * * *' do; end
+        sleep 0.7
+
+        if j0.threads.any?
+          j0.threads.size.should == 1
+          j1.threads.size.should == 0
+        else
+          j0.threads.size.should == 0
+          j1.threads.size.should == 1
+        end
 
-        job.paused?.should == false
+        @scheduler.mutexes.keys.sort.should == %w[ a b ]
       end
     end
+  end
+
+  context ':timeout => duration_or_point_in_time' do
+
+    it 'interrupts the job it is stashed to (duration)' do
+
+      counter = 0
+      toe = nil
+
+      job =
+        @scheduler.schedule_in '0s', :timeout => '1s' do
+          begin
+            counter = counter + 1
+            sleep 1.5
+            counter = counter + 1
+          rescue Rufus::Scheduler::TimeoutError => e
+            toe = e
+          end
+        end
+
+      sleep(3)
+
+      counter.should == 1
+      toe.class.should == Rufus::Scheduler::TimeoutError
+    end
+
+    it 'interrupts the job it is stashed to (point in time)' do
 
-    describe '#pause' do
+      counter = 0
 
-      it 'pauses the job' do
+      job =
+        @scheduler.schedule_in '0s', :timeout => Time.now + 1 do
+          begin
+            counter = counter + 1
+            sleep 1.5
+            counter = counter + 1
+          rescue Rufus::Scheduler::TimeoutError => e
+          end
+        end
 
-        job = @s.cron '* * * * *' do; end
+      sleep(3)
+
+      counter.should == 1
+    end
 
-        job.pause
+    it 'starts timing when the job enters successfully all its mutexes' do
 
-        job.paused?.should == true
+      t0, t1, t2 = nil
+
+      @scheduler.schedule_in '0s', :mutex => 'a' do
+        sleep 1
+        t0 = Time.now
       end
+
+      job =
+        @scheduler.schedule_in '0.5s', :mutex => 'a', :timeout => '1s' do
+          begin
+            t1 = Time.now
+            sleep 2
+          rescue Rufus::Scheduler::TimeoutError => e
+            t2 = Time.now
+          end
+        end
+
+      sleep 3
+
+      t0.should <= t1
+
+      d = t2 - t1
+      d.should >= 1.0
+      d.should < 1.5
     end
 
-    describe '#resume' do
+    it 'emits the timeout information to $stderr (default #on_error)' do
+
+      @scheduler.every('1s', :timeout => '0.5s') do
+        sleep 0.9
+      end
+
+      sleep 2
 
-      it 'resumes the job' do
+      $stderr.string.should match(/Rufus::Scheduler::TimeoutError/)
+    end
 
-        job = @s.cron '* * * * *' do; end
+    it 'does not prevent a repeat job from recurring' do
 
-        job.resume
+      counter = 0
 
-        job.paused?.should == false
+      @scheduler.every('1s', :timeout => '0.5s') do
+        counter = counter + 1
+        sleep 0.9
       end
+
+      sleep 3
+
+      counter.should > 1
     end
   end
 end