rufus-scheduler 3.0.0 → 3.0.9

data/spec/job_spec.rb

@@ -38,7 +38,7 @@ describe Rufus::Scheduler::Job do
 
       job = @scheduler.schedule_in '10d' do; end
 
-      job.last_time.should == nil
+      expect(job.last_time).to eq(nil)
     end
 
     it 'returns the last time the job fired' do
@@ -47,7 +47,7 @@ describe Rufus::Scheduler::Job do
 
       sleep 0.4
 
-      job.last_time.should_not == nil
+      expect(job.last_time).not_to eq(nil)
     end
   end
 
@@ -57,7 +57,7 @@ describe Rufus::Scheduler::Job do
 
       job = @scheduler.in('1d', :job => true) {}
 
-      job.threads.size.should == 0
+      expect(job.threads.size).to eq(0)
     end
 
     it 'returns an empty list after the job terminated' do
@@ -66,7 +66,7 @@ describe Rufus::Scheduler::Job do
 
       sleep 0.8
 
-      job.threads.size.should == 0
+      expect(job.threads.size).to eq(0)
     end
 
     it 'lists the threads the job currently runs in' do
@@ -78,10 +78,10 @@ describe Rufus::Scheduler::Job do
 
       sleep 0.4
 
-      job.threads.size.should == 1
+      expect(job.threads.size).to eq(1)
 
       t = job.threads.first
-      t[:rufus_scheduler_job].should == job
+      expect(t[:rufus_scheduler_job]).to eq(job)
     end
   end
 
@@ -95,7 +95,7 @@ describe Rufus::Scheduler::Job do
 
       job.kill
 
-      Thread.list.size.should == tls
+      expect(Thread.list.size).to eq(tls)
     end
 
     it 'makes the threads vacant' do
@@ -120,13 +120,13 @@ describe Rufus::Scheduler::Job do
       v1 = @scheduler.work_threads(:vacant).size
       a1 = @scheduler.work_threads(:active).size
 
-      counter.should == 0
+      expect(counter).to eq(0)
 
-      v0.should == 0
-      a0.should == 1
+      expect(v0).to eq(0)
+      expect(a0).to eq(1)
 
-      v1.should == 1
-      a1.should == 0
+      expect(v1).to eq(1)
+      expect(a1).to eq(0)
     end
   end
 
@@ -136,7 +136,7 @@ describe Rufus::Scheduler::Job do
 
       job = @scheduler.in('1d', :job => true) {}
 
-      job.running?.should == false
+      expect(job.running?).to eq(false)
     end
 
     it 'returns true when the job is running in at least one thread' do
@@ -145,7 +145,7 @@ describe Rufus::Scheduler::Job do
 
       sleep 0.4
 
-      job.running?.should == true
+      expect(job.running?).to eq(true)
     end
   end
 
@@ -155,7 +155,7 @@ describe Rufus::Scheduler::Job do
 
       job = @scheduler.schedule_in('1d') {}
 
-      job.scheduled?.should == true
+      expect(job.scheduled?).to eq(true)
     end
 
     it 'returns false when the job is not scheduled' do
@@ -164,7 +164,7 @@ describe Rufus::Scheduler::Job do
 
       sleep 0.4
 
-      job.scheduled?.should == false
+      expect(job.scheduled?).to eq(false)
     end
 
     it 'returns true for repeat jobs that are running' do
@@ -173,8 +173,72 @@ describe Rufus::Scheduler::Job do
 
       sleep 1
 
-      job.running?.should == true
-      job.scheduled?.should == true
+      expect(job.running?).to eq(true)
+      expect(job.scheduled?).to eq(true)
+    end
+  end
+
+  describe '#call' do
+
+    it 'calls the job (like it were a proc)' do
+
+      counter = 0
+
+      job =
+        @scheduler.schedule_in('0.5s') do
+          counter = counter + 1
+        end
+      job.call
+
+      sleep 0.8
+
+      expect(counter).to eq(2)
+    end
+  end
+
+  describe '#call(true)' do
+
+    it 'calls the job and let the scheduler handle errors' do
+
+      $err = nil
+
+      def @scheduler.on_error(job, err)
+        $err = "#{job.class} #{job.original} #{err.message}"
+      rescue
+        p $!
+      end
+
+      job =
+        @scheduler.schedule_in('1d') do
+          fail 'again'
+        end
+
+      job.call(true)
+
+      expect($err).to eq('Rufus::Scheduler::InJob 1d again')
+    end
+  end
+
+  describe '#call(false)' do
+
+    it 'calls the job and let errors slip through' do
+
+      job =
+        @scheduler.schedule_in('1d') do
+          fail 'fast'
+        end
+
+      begin
+
+        #job.call(false)
+        job.call # false is the default
+
+        expect(false).to eq(true)
+
+      rescue => ex
+
+        expect(ex.message).to eq('fast')
+      end
     end
   end
 
@@ -192,7 +256,7 @@ describe Rufus::Scheduler::Job do
 
         sleep 3
 
-        job[:counter].should > 1
+        expect(job[:counter]).to be > 1
       end
     end
 
@@ -202,7 +266,7 @@ describe Rufus::Scheduler::Job do
 
         job = @scheduler.schedule_in '1s' do; end
 
-        job[:nada].should == nil
+        expect(job[:nada]).to eq(nil)
       end
 
       it 'returns the value of a job-local variable' do
@@ -210,7 +274,7 @@ describe Rufus::Scheduler::Job do
         job = @scheduler.schedule_in '1s' do; end
         job[:x] = :y
 
-        job[:x].should == :y
+        expect(job[:x]).to eq(:y)
       end
     end
 
@@ -221,7 +285,7 @@ describe Rufus::Scheduler::Job do
         job = @scheduler.schedule_in '1s' do; end
         job[:x] = :y
 
-        job.key?(:x).should == true
+        expect(job.key?(:x)).to eq(true)
       end
     end
 
@@ -234,7 +298,7 @@ describe Rufus::Scheduler::Job do
         job['hello'] = :z
         job[123] = {}
 
-        job.keys.sort_by { |k| k.to_s }.should == [ 123, 'hello', :x ]
+        expect(job.keys.sort_by { |k| k.to_s }).to eq([ 123, 'hello', :x ])
       end
     end
   end
@@ -245,21 +309,21 @@ describe Rufus::Scheduler::Job do
 
       job = @scheduler.in '10d', :job => true, :tag => 't0' do; end
 
-      job.tags.should == %w[ t0 ]
+      expect(job.tags).to eq(%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 ]
+      expect(job.tags).to eq(%w[ t0 t1 ])
     end
 
     it 'turns tags into strings' do
 
       job = @scheduler.in '10d', :job => true, :tags => [ 1, 2 ] do; end
 
-      job.tags.should == %w[ 1 2 ]
+      expect(job.tags).to eq(%w[ 1 2 ])
     end
   end
 
@@ -274,11 +338,11 @@ describe Rufus::Scheduler::Job do
 
       sleep 0.4
 
-      job.threads.first.should == @scheduler.thread
+      expect(job.threads.first).to eq(@scheduler.thread)
 
       sleep 1.4
 
-      job.threads.size.should == 0
+      expect(job.threads.size).to eq(0)
     end
   end
 
@@ -293,11 +357,11 @@ describe Rufus::Scheduler::Job do
 
       sleep 0.4
 
-      job.threads.first.should_not == @scheduler.thread
+      expect(job.threads.first).not_to eq(@scheduler.thread)
 
       sleep 1.4
 
-      job.threads.size.should == 0
+      expect(job.threads.size).to eq(0)
     end
   end
 
@@ -314,7 +378,7 @@ describe Rufus::Scheduler::Job do
 
         sleep 3
 
-        job.threads.size.should > 1
+        expect(job.threads.size).to be > 1
       end
     end
 
@@ -329,7 +393,7 @@ describe Rufus::Scheduler::Job do
 
         sleep 3
 
-        job.threads.size.should == 1
+        expect(job.threads.size).to eq(1)
       end
     end
   end
@@ -352,14 +416,14 @@ describe Rufus::Scheduler::Job do
         sleep 0.7
 
         if j0.threads.any?
-          j0.threads.size.should == 1
-          j1.threads.size.should == 0
+          expect(j0.threads.size).to eq(1)
+          expect(j1.threads.size).to eq(0)
         else
-          j0.threads.size.should == 0
-          j1.threads.size.should == 1
+          expect(j0.threads.size).to eq(0)
+          expect(j1.threads.size).to eq(1)
         end
 
-        @scheduler.mutexes.keys.should == %w[ vladivostok ]
+        expect(@scheduler.mutexes.keys).to eq(%w[ vladivostok ])
       end
     end
 
@@ -375,14 +439,14 @@ describe Rufus::Scheduler::Job do
         sleep 0.7
 
         if j0.threads.any?
-          j0.threads.size.should == 1
-          j1.threads.size.should == 0
+          expect(j0.threads.size).to eq(1)
+          expect(j1.threads.size).to eq(0)
         else
-          j0.threads.size.should == 0
-          j1.threads.size.should == 1
+          expect(j0.threads.size).to eq(0)
+          expect(j1.threads.size).to eq(1)
         end
 
-        @scheduler.mutexes.keys.should == []
+        expect(@scheduler.mutexes.keys).to eq([])
       end
     end
 
@@ -402,14 +466,14 @@ describe Rufus::Scheduler::Job do
         sleep 0.7
 
         if j0.threads.any?
-          j0.threads.size.should == 1
-          j1.threads.size.should == 0
+          expect(j0.threads.size).to eq(1)
+          expect(j1.threads.size).to eq(0)
         else
-          j0.threads.size.should == 0
-          j1.threads.size.should == 1
+          expect(j0.threads.size).to eq(0)
+          expect(j1.threads.size).to eq(1)
         end
 
-        @scheduler.mutexes.keys.sort.should == %w[ a b ]
+        expect(@scheduler.mutexes.keys.sort).to eq(%w[ a b ])
       end
     end
   end
@@ -434,8 +498,8 @@ describe Rufus::Scheduler::Job do
 
       sleep(3)
 
-      counter.should == 1
-      toe.class.should == Rufus::Scheduler::TimeoutError
+      expect(counter).to eq(1)
+      expect(toe.class).to eq(Rufus::Scheduler::TimeoutError)
     end
 
     it 'interrupts the job it is stashed to (point in time)' do
@@ -454,7 +518,7 @@ describe Rufus::Scheduler::Job do
 
       sleep(3)
 
-      counter.should == 1
+      expect(counter).to eq(1)
     end
 
     it 'starts timing when the job enters successfully all its mutexes' do
@@ -478,11 +542,11 @@ describe Rufus::Scheduler::Job do
 
       sleep 3
 
-      t0.should <= t1
+      expect(t0).to be <= t1
 
       d = t2 - t1
-      d.should >= 1.0
-      d.should < 1.5
+      expect(d).to be >= 1.0
+      expect(d).to be < 1.5
     end
 
     it 'emits the timeout information to $stderr (default #on_error)' do
@@ -493,7 +557,7 @@ describe Rufus::Scheduler::Job do
 
       sleep 2
 
-      $stderr.string.should match(/Rufus::Scheduler::TimeoutError/)
+      expect($stderr.string).to match(/Rufus::Scheduler::TimeoutError/)
     end
 
     it 'does not prevent a repeat job from recurring' do
@@ -507,7 +571,60 @@ describe Rufus::Scheduler::Job do
 
       sleep 3
 
-      counter.should > 1
+      expect(counter).to be > 1
+    end
+  end
+
+  context 'work time' do
+
+    describe '#last_work_time' do
+
+      it 'starts at 0' do
+
+        job = @scheduler.schedule_every '5m' do; end
+
+        expect(job.last_work_time).to eq(0.0)
+      end
+
+      it 'keeps track of how long the work was upon last trigger' do
+
+        job =
+          @scheduler.schedule_in '0.5s'  do
+            sleep 0.7
+          end
+
+        sleep 2
+
+        expect(job.last_work_time).to be >= 0.7
+        expect(job.last_work_time).to be < 0.8
+      end
+    end
+
+    describe '#mean_work_time' do
+
+      it 'starts at 0' do
+
+        job = @scheduler.schedule_every '5m' do; end
+
+        expect(job.mean_work_time).to eq(0.0)
+      end
+
+      it 'gathers work times and computes the mean' do
+
+        job =
+          @scheduler.schedule_every '0.5s' do |j|
+            #p j.last_work_time
+            #p j.mean_work_time
+            sleep 0.01 * (j.count + 1)
+          end
+
+        sleep 4.6
+
+        expect(job.last_work_time).to be >= 0.08
+        expect(job.last_work_time).to be < 0.099
+        expect(job.mean_work_time).to be > 0.05
+        expect(job.mean_work_time).to be < 0.06
+      end
     end
   end
 end

data/spec/lock_custom_spec.rb

@@ -0,0 +1,47 @@
+
+#
+# Specifying rufus-scheduler
+#
+# Fri Nov  1 05:56:03 JST 2013
+#
+# Ishinomaki
+#
+
+require 'spec_helper'
+
+
+describe Rufus::Scheduler do
+
+  class LosingLockScheduler < Rufus::Scheduler
+
+    attr_reader :counter
+
+    def initialize
+      super
+      @counter = 0
+    end
+
+    def confirm_lock
+      @counter = @counter + 1
+      false
+    end
+  end
+
+  context 'custom locks' do
+
+    it 'does not trigger when #confirm_lock returns false' do
+
+      s = LosingLockScheduler.new
+
+      count = 0
+
+      s.in('0s') { count = count + 1 }
+
+      sleep 0.7
+
+      expect(count).to eq(0)
+      expect(s.counter).to eq(1)
+    end
+  end
+end
+

data/spec/lock_flock_spec.rb

@@ -0,0 +1,47 @@
+
+#
+# Specifying rufus-scheduler
+#
+# Sat Aug 16 05:43:06 JST 2014
+# added by @ecin
+#
+
+require 'spec_helper'
+
+
+describe Rufus::Scheduler::FileLock do
+
+  before :each do
+
+    @lock_path = '.rufus-scheduler.lock'
+    @lock = Rufus::Scheduler::FileLock.new(@lock_path)
+  end
+
+  after :each do
+
+    FileUtils.rm_f(@lock_path)
+    FileUtils.rm_f('lock.txt')
+  end
+
+  context ':scheduler_lock => Rufus::Scheduler::FileLock.new(path)' do
+
+    it 'writes down a .rufus-scheduler.lock file' do
+
+      @lock.lock
+
+      line = File.read(@lock_path)
+
+      expect(line).to match(/pid: #{$$}/)
+    end
+
+    it '"flocks" the lock file' do
+
+      @lock.lock
+
+      f = File.new(@lock_path, 'a')
+
+      expect(f.flock(File::LOCK_NB | File::LOCK_EX)).to eq(false)
+    end
+  end
+end
+

data/spec/{lockfile_spec.rb → lock_lockfile_spec.rb}

@@ -25,7 +25,7 @@ describe Rufus::Scheduler do
       line = File.read('.rufus-scheduler.lock')
 
       #p line
-      line.should match(/pid: #{$$}/)
+      expect(line).to match(/pid: #{$$}/)
     end
 
     it '"flocks" the lock file' do
@@ -34,7 +34,7 @@ describe Rufus::Scheduler do
 
       f = File.new('.rufus-scheduler.lock', 'a')
 
-      f.flock(File::LOCK_NB | File::LOCK_EX).should == false
+      expect(f.flock(File::LOCK_NB | File::LOCK_EX)).to eq(false)
     end
 
     it 'prevents newer schedulers from starting' do
@@ -42,8 +42,8 @@ describe Rufus::Scheduler do
       s0 = Rufus::Scheduler.new :lockfile => '.rufus-scheduler.lock'
       s1 = Rufus::Scheduler.new :lockfile => '.rufus-scheduler.lock'
 
-      s0.started_at.should_not == nil
-      s1.started_at.should == nil
+      expect(s0.started_at).not_to eq(nil)
+      expect(s1.started_at).to eq(nil)
     end
 
     it 'releases the lockfile when shutting down' do
@@ -54,7 +54,7 @@ describe Rufus::Scheduler do
 
       f = File.new('.rufus-scheduler.lock', 'a')
 
-      f.flock(File::LOCK_NB | File::LOCK_EX).should == 0
+      expect(f.flock(File::LOCK_NB | File::LOCK_EX)).to eq(0)
     end
   end
 end

data/spec/lock_spec.rb

@@ -0,0 +1,59 @@
+
+#
+# Specifying rufus-scheduler
+#
+# Sat Aug 16 05:42:11 JST 2014
+# added by @ecin
+#
+
+require 'spec_helper'
+
+
+describe Rufus::Scheduler do
+
+  context "when running multiple schedulers side-by-side" do
+
+    class AlwaysLock
+      def lock; true; end
+      def unlock; true; end
+      def locked?; true; end
+    end
+
+    class NeverLock
+      def lock; false; end
+      def unlock; true; end
+      def locked?; true; end
+    end
+
+    it "only starts if it can acquire a scheduler lock" do
+
+      main = Rufus::Scheduler.new :scheduler_lock => AlwaysLock.new
+      backup = Rufus::Scheduler.new :scheduler_lock => NeverLock.new
+
+      expect(main).to be_up
+      expect(backup).to be_down
+    end
+
+    it "only triggers jobs when it can acquire a trigger lock" do
+
+      main = Rufus::Scheduler.new(:trigger_lock => AlwaysLock.new)
+      backup = Rufus::Scheduler.new(:trigger_lock => NeverLock.new)
+
+      expect(main).to be_up
+      expect(backup).to be_up
+
+      counter = 0
+      job = proc { counter += 1 }
+      main.schedule_in(0, job)
+      backup.schedule_in(0, job)
+
+      sleep 0.5
+
+      expect(main.jobs).to be_empty
+      expect(backup.jobs.count).to eq(1)
+      expect(backup.jobs.first.next_time).to be(false)
+      expect(counter).to eq(1)
+    end
+  end
+end
+