rufus-scheduler 3.0.0 → 3.0.9

data/spec/scheduler_spec.rb

@@ -20,26 +20,33 @@ describe Rufus::Scheduler do
         t[:name] == "rufus_scheduler_#{scheduler.object_id}_scheduler"
       }
 
-      t[:rufus_scheduler].should == scheduler
+      expect(t[:rufus_scheduler]).to eq(scheduler)
     end
 
-    it 'sets a :rufus_scheduler thread local var' do
+    it 'sets :name and :rufus_scheduler in the scheduler thread local vars' do
 
       scheduler = Rufus::Scheduler.new
+
+      expect(scheduler.thread[:name]).to eq(
+        "rufus_scheduler_#{scheduler.object_id}_scheduler"
+      )
+      expect(scheduler.thread[:rufus_scheduler]).to eq(
+        scheduler
+      )
     end
 
     it 'accepts a :frequency => integer option' do
 
       scheduler = Rufus::Scheduler.new(:frequency => 2)
 
-      scheduler.frequency.should == 2
+      expect(scheduler.frequency).to eq(2)
     end
 
     it 'accepts a :frequency => "2h1m" option' do
 
       scheduler = Rufus::Scheduler.new(:frequency => '2h1m')
 
-      scheduler.frequency.should == 3600 * 2 + 60
+      expect(scheduler.frequency).to eq(3600 * 2 + 60)
     end
 
     it 'accepts a :thread_name option' do
@@ -48,7 +55,7 @@ describe Rufus::Scheduler do
 
       t = Thread.list.find { |t| t[:name] == 'oliphant' }
 
-      t[:rufus_scheduler].should == scheduler
+      expect(t[:rufus_scheduler]).to eq(scheduler)
     end
 
     #it 'accepts a :min_work_threads option' do
@@ -60,7 +67,7 @@ describe Rufus::Scheduler do
 
       scheduler = Rufus::Scheduler.new(:max_work_threads => 9)
 
-      scheduler.max_work_threads.should == 9
+      expect(scheduler.max_work_threads).to eq(9)
     end
   end
 
@@ -80,7 +87,7 @@ describe Rufus::Scheduler do
 
       sleep 0.4
 
-      j.should == job
+      expect(j).to eq(job)
     end
 
     it 'passes the trigger time as second block argument' do
@@ -90,7 +97,7 @@ describe Rufus::Scheduler do
 
       sleep 0.4
 
-      t.class.should == Time
+      expect(t.class).to eq(Time)
     end
 
     class MyHandler
@@ -111,7 +118,7 @@ describe Rufus::Scheduler do
 
       sleep 0.4
 
-      mh.counter.should == 1
+      expect(mh.counter).to eq(1)
     end
 
     class MyOtherHandler
@@ -130,7 +137,7 @@ describe Rufus::Scheduler do
 
       sleep 0.4
 
-      job.handler.counter.should == 1
+      expect(job.handler.counter).to eq(1)
     end
 
     it 'accepts a class as callable' do
@@ -145,16 +152,16 @@ describe Rufus::Scheduler do
 
       sleep 0.4
 
-      job.handler.value.should == 7
+      expect(job.handler.value).to eq(7)
     end
 
     it 'raises if the scheduler is shutting down' do
 
       @scheduler.shutdown
 
-      lambda {
+      expect {
         @scheduler.in('0s') { puts 'hhhhhhhhhhhello!!' }
-      }.should raise_error(RuntimeError)
+      }.to raise_error(Rufus::Scheduler::NotRunningError)
     end
   end
 
@@ -191,23 +198,23 @@ describe Rufus::Scheduler do
 
       j = @scheduler.schedule '1s' do; end
 
-      j.class.should == Rufus::Scheduler::InJob
-      j.original.should == '1s'
+      expect(j.class).to eq(Rufus::Scheduler::InJob)
+      expect(j.original).to eq('1s')
     end
 
     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'
+      expect(j.class).to eq(Rufus::Scheduler::AtJob)
+      expect(j.next_time.strftime('%Y %m %d')).to eq('2070 12 24')
     end
 
     it 'accepts a cron string and schedules a CronJob' do
 
       j = @scheduler.schedule '* * * * *' do; end
 
-      j.class.should == Rufus::Scheduler::CronJob
+      expect(j.class).to eq(Rufus::Scheduler::CronJob)
     end
   end
 
@@ -217,14 +224,14 @@ describe Rufus::Scheduler do
 
       j = @scheduler.repeat '1s' do; end
 
-      j.class.should == Rufus::Scheduler::EveryJob
+      expect(j.class).to eq(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
+      expect(j.class).to eq(Rufus::Scheduler::CronJob)
     end
   end
 
@@ -234,22 +241,22 @@ describe Rufus::Scheduler do
 
       job = @scheduler.schedule_in '10d' do; end
 
-      job.unscheduled_at.should == nil
+      expect(job.unscheduled_at).to eq(nil)
 
       @scheduler.unschedule(job.id)
 
-      job.unscheduled_at.should_not == nil
+      expect(job.unscheduled_at).not_to eq(nil)
     end
 
     it 'accepts jobs' do
 
       job = @scheduler.schedule_in '10d' do; end
 
-      job.unscheduled_at.should == nil
+      expect(job.unscheduled_at).to eq(nil)
 
       @scheduler.unschedule(job)
 
-      job.unscheduled_at.should_not == nil
+      expect(job.unscheduled_at).not_to eq(nil)
     end
 
     it 'carefully unschedules repeat jobs' do
@@ -267,7 +274,7 @@ describe Rufus::Scheduler do
       @scheduler.unschedule(job)
 
       sleep 1.5
-      counter.should == c
+      expect(counter).to eq(c)
     end
   end
 
@@ -275,7 +282,7 @@ describe Rufus::Scheduler do
 
     it 'returns the uptime as a float' do
 
-      @scheduler.uptime.should >= 0.0
+      expect(@scheduler.uptime).to be >= 0.0
     end
   end
 
@@ -285,7 +292,7 @@ describe Rufus::Scheduler do
 
       sleep 1
 
-      @scheduler.uptime_s.should match(/^[12]s\d+$/)
+      expect(@scheduler.uptime_s).to match(/^[12]s\d+$/)
     end
   end
 
@@ -295,13 +302,13 @@ describe Rufus::Scheduler do
 
       t = Thread.new { @scheduler.join; Thread.current['a'] = 'over' }
 
-      t['a'].should == nil
+      expect(t['a']).to eq(nil)
 
       @scheduler.shutdown
 
       sleep(1)
 
-      t['a'].should == 'over'
+      expect(t['a']).to eq('over')
     end
   end
 
@@ -309,7 +316,7 @@ describe Rufus::Scheduler do
 
     it 'returns nil if there is no corresponding Job instance' do
 
-      @scheduler.job('nada').should == nil
+      expect(@scheduler.job('nada')).to eq(nil)
     end
 
     it 'returns the corresponding Job instance' do
@@ -318,7 +325,7 @@ describe Rufus::Scheduler do
 
       sleep(1) # give it some time to get scheduled
 
-      @scheduler.job(job_id).job_id.should == job_id
+      expect(@scheduler.job(job_id).job_id).to eq(job_id)
     end
   end
 
@@ -348,7 +355,7 @@ describe Rufus::Scheduler do
 
     it 'just lists the main thread (scheduler thread) when no job is scheduled' do
 
-      @scheduler.threads.should == [ @scheduler.thread ]
+      expect(@scheduler.threads).to eq([ @scheduler.thread ])
     end
 
     it 'lists all the threads a scheduler uses' do
@@ -359,51 +366,39 @@ describe Rufus::Scheduler do
 
       sleep 0.4
 
-      @scheduler.threads.size.should == 2
+      expect(@scheduler.threads.size).to eq(2)
     end
   end
 
-  describe '#work_threads(:all)' do
+  describe '#work_threads(:all | :vacant)' do
 
     it 'returns an empty array when the scheduler has not yet done anything' do
 
-      @scheduler.work_threads.should == []
+      expect(@scheduler.work_threads).to eq([])
+      expect(@scheduler.work_threads(:all)).to eq([])
+      expect(@scheduler.work_threads(:vacant)).to eq([])
     end
 
-    it 'lists all the work threads in the pool' do
+    it 'lists the [vacant] work threads in the pool' do
 
       @scheduler.in '0s' do
-        # nada
+        sleep(0.2)
       end
       @scheduler.in '0s' do
-        sleep(2)
+        sleep(2.0)
       end
 
-      sleep 0.6
-
-      @scheduler.work_threads.size.should == 2
-    end
-  end
-
-  describe '#work_threads(:vacant)' do
-
-    it 'returns an empty array when the scheduler has not yet done anything' do
-
-      @scheduler.work_threads(:vacant).should == []
-    end
-
-    it 'lists all the work threads in the pool' do
+      sleep 0.7
 
-      @scheduler.in '0s' do
-        # nada
-      end
-      @scheduler.in '0s' do
-        sleep(2)
+      if @scheduler.work_threads.size == 1
+        expect(@scheduler.work_threads.size).to eq(1)
+        expect(@scheduler.work_threads(:all).size).to eq(1)
+        expect(@scheduler.work_threads(:vacant).size).to eq(0)
+      else
+        expect(@scheduler.work_threads.size).to eq(2)
+        expect(@scheduler.work_threads(:all).size).to eq(2)
+        expect(@scheduler.work_threads(:vacant).size).to eq(1)
       end
-
-      sleep 0.4
-
-      @scheduler.work_threads(:vacant).size.should == 1
     end
   end
 
@@ -411,7 +406,7 @@ describe Rufus::Scheduler do
 
     it 'returns [] when there are no jobs running' do
 
-      @scheduler.work_threads(:active).should == []
+      expect(@scheduler.work_threads(:active)).to eq([])
     end
 
     it 'returns the list of threads of the running jobs' do
@@ -423,14 +418,14 @@ describe Rufus::Scheduler do
 
       sleep 0.4
 
-      @scheduler.work_threads(:active).size.should == 1
+      expect(@scheduler.work_threads(:active).size).to eq(1)
 
       t = @scheduler.work_threads(:active).first
 
-      t.class.should == Thread
-      t[@scheduler.thread_key].should == true
-      t[:rufus_scheduler_job].should == job
-      t[:rufus_scheduler_time].should_not == nil
+      expect(t.class).to eq(Thread)
+      expect(t[@scheduler.thread_key]).to eq(true)
+      expect(t[:rufus_scheduler_job]).to eq(job)
+      expect(t[:rufus_scheduler_time]).not_to eq(nil)
     end
 
     it 'does not return threads from other schedulers' do
@@ -444,7 +439,7 @@ describe Rufus::Scheduler do
 
       sleep 0.4
 
-      scheduler.work_threads(:active).should == []
+      expect(scheduler.work_threads(:active)).to eq([])
 
       scheduler.shutdown
     end
@@ -452,7 +447,7 @@ describe Rufus::Scheduler do
 
   #describe '#min_work_threads' do
   #  it 'returns the min job thread count' do
-  #    @scheduler.min_work_threads.should == 7
+  #    @scheduler.min_work_threads.should == 3
   #  end
   #end
   #describe '#min_work_threads=' do
@@ -466,7 +461,7 @@ describe Rufus::Scheduler do
 
     it 'returns the max job thread count' do
 
-      @scheduler.max_work_threads.should == 35
+      expect(@scheduler.max_work_threads).to eq(28)
     end
   end
 
@@ -476,7 +471,7 @@ describe Rufus::Scheduler do
 
       @scheduler.max_work_threads = 14
 
-      @scheduler.max_work_threads.should == 14
+      expect(@scheduler.max_work_threads).to eq(14)
     end
   end
 
@@ -504,7 +499,7 @@ describe Rufus::Scheduler do
 
     it 'returns [] when there are no running jobs' do
 
-      @scheduler.running_jobs.should == []
+      expect(@scheduler.running_jobs).to eq([])
     end
 
     it 'returns a list of running Job instances' do
@@ -516,8 +511,8 @@ describe Rufus::Scheduler do
 
       sleep 0.4
 
-      job.running?.should == true
-      @scheduler.running_jobs.should == [ job ]
+      expect(job.running?).to eq(true)
+      expect(@scheduler.running_jobs).to eq([ job ])
     end
 
     it 'does not return twice the same job' do
@@ -529,8 +524,8 @@ describe Rufus::Scheduler do
 
       sleep 1.5
 
-      job.running?.should == true
-      @scheduler.running_jobs.should == [ job ]
+      expect(job.running?).to eq(true)
+      expect(@scheduler.running_jobs).to eq([ job ])
     end
   end
 
@@ -545,14 +540,87 @@ describe Rufus::Scheduler do
         sleep 3
       end
 
-      sleep 0.4
+      sleep 0.49
 
-      @scheduler.running_jobs(:tag => 't0').map(&:original).should ==
+      expect(@scheduler.running_jobs(:tag => 't0').map(&:original)).to eq(
         %w[ 0.1s ]
-      @scheduler.running_jobs(:tag => 't1').map(&:original).should ==
+      )
+      expect(@scheduler.running_jobs(:tag => 't1').map(&:original)).to eq(
         %w[ 0.2s ]
-      @scheduler.running_jobs(:tags => %w[ t0 t1 ]).map(&:original).should ==
+      )
+      expect(@scheduler.running_jobs(:tags => %w[ t0 t1 ]).map(&:original)).to eq(
         []
+      )
+    end
+  end
+
+  describe '#occurrences(time0, time1)' do
+
+    it 'returns a { job => [ times ] } of job occurrences' do
+
+      j0 = @scheduler.schedule_in '7m' do; end
+      j1 = @scheduler.schedule_at '10m' do; end
+      j2 = @scheduler.schedule_every '5m' do; end
+      j3 = @scheduler.schedule_interval '5m' do; end
+      j4 = @scheduler.schedule_cron '* * * * *' do; end
+
+      h = @scheduler.occurrences(Time.now + 4 * 60, Time.now + 11 * 60)
+
+      expect(h.size).to eq(5)
+      expect(h[j0]).to eq([ j0.next_time ])
+      expect(h[j1]).to eq([ j1.next_time ])
+      expect(h[j2].size).to eq(2)
+      expect(h[j3].size).to eq(2)
+      expect(h[j4].size).to eq(7)
+    end
+
+    it 'returns a [ [ time, job ], ... ] of job occurrences when :timeline' do
+
+      j0 = @scheduler.schedule_in '5m' do; end
+      j1 = @scheduler.schedule_in '10m' do; end
+
+      a =
+        @scheduler.occurrences(Time.now + 4 * 60, Time.now + 11 * 60, :timeline)
+
+      expect(a[0][0]).to be_within_1s_of(Time.now + 5 * 60)
+      expect(a[0][1]).to eq(j0)
+      expect(a[1][0]).to be_within_1s_of(Time.now + 10 * 60)
+      expect(a[1][1]).to eq(j1)
+    end
+
+    it 'respects :first_at for repeat jobs' do
+
+      j0 = @scheduler.schedule_every '5m', :first_in => '10m' do; end
+
+      h = @scheduler.occurrences(Time.now + 4 * 60, Time.now + 16 * 60)
+
+      expect(h[j0][0]).to be_within_1s_of(Time.now + 10 * 60)
+      expect(h[j0][1]).to be_within_1s_of(Time.now + 15 * 60)
+    end
+
+    it 'respects :times for repeat jobs' do
+
+      j0 = @scheduler.schedule_every '1m', :times => 10 do; end
+
+      h = @scheduler.occurrences(Time.now + 4 * 60, Time.now + 16 * 60)
+
+      expect(h[j0].size).to eq(6)
+    end
+  end
+
+  describe '#timeline(time0, time1)' do
+
+    it 'returns a [ [ time, job ], ... ] of job occurrences' do
+
+      j0 = @scheduler.schedule_in '5m' do; end
+      j1 = @scheduler.schedule_in '10m' do; end
+
+      a = @scheduler.timeline(Time.now + 4 * 60, Time.now + 11 * 60)
+
+      expect(a[0][0]).to be_within_1s_of(Time.now + 5 * 60)
+      expect(a[0][1]).to eq(j0)
+      expect(a[1][0]).to be_within_1s_of(Time.now + 10 * 60)
+      expect(a[1][1]).to eq(j1)
     end
   end
 
@@ -566,7 +634,7 @@ describe Rufus::Scheduler do
 
       @scheduler.shutdown
 
-      @scheduler.uptime.should == nil
+      expect(@scheduler.uptime).to eq(nil)
     end
 
     it 'shuts the scheduler down' do
@@ -580,14 +648,14 @@ describe Rufus::Scheduler do
         t[:name] == "rufus_scheduler_#{@scheduler.object_id}"
       }
 
-      t.should == nil
+      expect(t).to eq(nil)
     end
 
     it 'has a #stop alias' do
 
       @scheduler.stop
 
-      @scheduler.uptime.should == nil
+      expect(@scheduler.uptime).to eq(nil)
     end
 
     #it 'has a #close alias'
@@ -608,10 +676,10 @@ describe Rufus::Scheduler do
 
       @scheduler.shutdown(:wait)
 
-      counter.should == 1
-      @scheduler.uptime.should == nil
-      @scheduler.running_jobs.should == []
-      @scheduler.threads.should == []
+      expect(counter).to eq(1)
+      expect(@scheduler.uptime).to eq(nil)
+      expect(@scheduler.running_jobs).to eq([])
+      expect(@scheduler.threads).to eq([])
     end
   end
 
@@ -636,10 +704,10 @@ describe Rufus::Scheduler do
 
       sleep 1.4
 
-      counter.should == 0
-      @scheduler.uptime.should == nil
-      @scheduler.running_jobs.should == []
-      @scheduler.threads.should == []
+      expect(counter).to eq(0)
+      expect(@scheduler.uptime).to eq(nil)
+      expect(@scheduler.running_jobs).to eq([])
+      expect(@scheduler.threads).to eq([])
     end
   end
 
@@ -653,7 +721,7 @@ describe Rufus::Scheduler do
 
       sleep(3)
 
-      job.last_time.should == nil
+      expect(job.last_time).to eq(nil)
     end
   end
 
@@ -668,7 +736,7 @@ describe Rufus::Scheduler do
       @scheduler.resume
       sleep(2)
 
-      job.last_time.should_not == nil
+      expect(job.last_time).not_to eq(nil)
     end
   end
 
@@ -677,17 +745,40 @@ describe Rufus::Scheduler do
     it 'returns true if the scheduler is paused' do
 
       @scheduler.pause
-      @scheduler.paused?.should == true
+      expect(@scheduler.paused?).to eq(true)
     end
 
     it 'returns false if the scheduler is not paused' do
 
-      @scheduler.paused?.should == false
+      expect(@scheduler.paused?).to eq(false)
 
       @scheduler.pause
       @scheduler.resume
 
-      @scheduler.paused?.should == false
+      expect(@scheduler.paused?).to eq(false)
+    end
+  end
+
+  describe '#down?' do
+
+    it 'returns true when the scheduler is down' do
+
+      @scheduler.shutdown
+
+      expect(@scheduler.down?).to eq(true)
+    end
+
+    it 'returns false when the scheduler is up' do
+
+      expect(@scheduler.down?).to eq(false)
+    end
+  end
+
+  describe '#up?' do
+
+    it 'returns true when the scheduler is up' do
+
+      expect(@scheduler.up?).to eq(true)
     end
   end
 
@@ -699,7 +790,7 @@ describe Rufus::Scheduler do
 
     it 'is empty at the beginning' do
 
-      @scheduler.jobs.should == []
+      expect(@scheduler.jobs).to eq([])
     end
 
     it 'returns the list of scheduled jobs' do
@@ -711,7 +802,7 @@ describe Rufus::Scheduler do
 
       jobs = @scheduler.jobs
 
-      jobs.collect { |j| j.original }.sort.should == %w[ 10d 1w ]
+      expect(jobs.collect { |j| j.original }.sort).to eq(%w[ 10d 1w ])
     end
 
     it 'returns all the jobs (even those pending reschedule)' do
@@ -722,7 +813,7 @@ describe Rufus::Scheduler do
 
       sleep 0.4
 
-      @scheduler.jobs.size.should == 1
+      expect(@scheduler.jobs.size).to eq(1)
     end
 
     it 'does not return unscheduled jobs' do
@@ -736,7 +827,7 @@ describe Rufus::Scheduler do
 
       job.unschedule
 
-      @scheduler.jobs.size.should == 0
+      expect(@scheduler.jobs.size).to eq(0)
     end
   end
 
@@ -744,8 +835,8 @@ describe Rufus::Scheduler 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 == []
+      expect(@scheduler.jobs(:tag => 'nada')).to eq([])
+      expect(@scheduler.jobs(:tags => %w[ nada hello ])).to eq([])
     end
 
     it 'returns the jobs with the corresponding tag' do
@@ -754,12 +845,15 @@ describe Rufus::Scheduler do
       @scheduler.every '2h', :tag => %w[ t0 t1 ] do; end
       @scheduler.every '3h' do; end
 
-      @scheduler.jobs(:tags => 't0').map(&:original).sort.should ==
+      expect(@scheduler.jobs(:tags => 't0').map(&:original).sort).to eq(
         %w[ 10d 2h ]
-      @scheduler.jobs(:tags => 't1').map(&:original).sort.should ==
+      )
+      expect(@scheduler.jobs(:tags => 't1').map(&:original).sort).to eq(
         %w[ 2h ]
-      @scheduler.jobs(:tags => [ 't1', 't0' ]).map(&:original).sort.should ==
+      )
+      expect(@scheduler.jobs(:tags => [ 't1', 't0' ]).map(&:original).sort).to eq(
         %w[ 2h ]
+      )
     end
   end
 
@@ -773,7 +867,7 @@ describe Rufus::Scheduler do
 
       jobs = @scheduler.every_jobs
 
-      jobs.collect { |j| j.original }.sort.should == %w[ 5m ]
+      expect(jobs.collect { |j| j.original }.sort).to eq(%w[ 5m ])
     end
   end
 
@@ -787,7 +881,7 @@ describe Rufus::Scheduler do
 
       jobs = @scheduler.at_jobs
 
-      jobs.collect { |j| j.original }.sort.should == [ '2030/12/12 12:10:00' ]
+      expect(jobs.collect { |j| j.original }.sort).to eq([ '2030/12/12 12:10:00' ])
     end
   end
 
@@ -801,7 +895,7 @@ describe Rufus::Scheduler do
 
       jobs = @scheduler.in_jobs
 
-      jobs.collect { |j| j.original }.sort.should == %w[ 10d ]
+      expect(jobs.collect { |j| j.original }.sort).to eq(%w[ 10d ])
     end
   end
 
@@ -816,7 +910,7 @@ describe Rufus::Scheduler do
 
       jobs = @scheduler.cron_jobs
 
-      jobs.collect { |j| j.original }.sort.should == [ '* * * * *' ]
+      expect(jobs.collect { |j| j.original }.sort).to eq([ '* * * * *' ])
     end
   end
 
@@ -832,7 +926,7 @@ describe Rufus::Scheduler do
 
       jobs = @scheduler.interval_jobs
 
-      jobs.collect { |j| j.original }.sort.should == %w[ 7m ]
+      expect(jobs.collect { |j| j.original }.sort).to eq(%w[ 7m ])
     end
   end
 
@@ -857,7 +951,7 @@ describe Rufus::Scheduler do
 
       sleep 0.7
 
-      $out.should == [ "pre #{job_id}", job_id ]
+      expect($out).to eq([ "pre #{job_id}", job_id ])
     end
 
     it 'accepts the job and the triggerTime as argument' do
@@ -874,9 +968,9 @@ describe Rufus::Scheduler do
 
       sleep 0.7
 
-      $tt.class.should == Time
-      $tt.should > start
-      $tt.should < Time.now
+      expect($tt.class).to eq(Time)
+      expect($tt).to be > start
+      expect($tt).to be < Time.now
     end
 
     context 'when it returns false' do
@@ -897,7 +991,7 @@ describe Rufus::Scheduler do
 
         sleep 0.7
 
-        $out.should == [ "pre #{job_id}" ]
+        expect($out).to eq([ "pre #{job_id}" ])
       end
     end
   end
@@ -919,7 +1013,7 @@ describe Rufus::Scheduler do
 
       sleep 0.7
 
-      $out.should == [ job_id, "post #{job_id}" ]
+      expect($out).to eq([ job_id, "post #{job_id}" ])
     end
   end
 
@@ -939,8 +1033,8 @@ describe Rufus::Scheduler do
       s0 = Rufus::Scheduler.singleton
       s1 = Rufus::Scheduler.s
 
-      s0.class.should == Rufus::Scheduler
-      s1.object_id.should == s0.object_id
+      expect(s0.class).to eq(Rufus::Scheduler)
+      expect(s1.object_id).to eq(s0.object_id)
     end
 
     it 'accepts initialization parameters' do
@@ -948,7 +1042,7 @@ describe Rufus::Scheduler do
       s = Rufus::Scheduler.singleton(:max_work_threads => 77)
       s = Rufus::Scheduler.singleton(:max_work_threads => 42)
 
-      s.max_work_threads.should == 77
+      expect(s.max_work_threads).to eq(77)
     end
   end
 end