rufus-scheduler 3.0.7 → 3.0.8

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,8 @@ 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
 
@@ -192,7 +192,7 @@ describe Rufus::Scheduler::Job do
 
       sleep 0.8
 
-      counter.should == 2
+      expect(counter).to eq(2)
     end
   end
 
@@ -215,7 +215,7 @@ describe Rufus::Scheduler::Job do
 
       job.call(true)
 
-      $err.should == 'Rufus::Scheduler::InJob 1d again'
+      expect($err).to eq('Rufus::Scheduler::InJob 1d again')
     end
   end
 
@@ -233,11 +233,11 @@ describe Rufus::Scheduler::Job do
         #job.call(false)
         job.call # false is the default
 
-        false.should == true
+        expect(false).to eq(true)
 
       rescue => ex
 
-        ex.message.should == 'fast'
+        expect(ex.message).to eq('fast')
       end
     end
   end
@@ -256,7 +256,7 @@ describe Rufus::Scheduler::Job do
 
         sleep 3
 
-        job[:counter].should > 1
+        expect(job[:counter]).to be > 1
       end
     end
 
@@ -266,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
@@ -274,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
 
@@ -285,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
 
@@ -298,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
@@ -309,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
 
@@ -338,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
 
@@ -357,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
 
@@ -378,7 +378,7 @@ describe Rufus::Scheduler::Job do
 
         sleep 3
 
-        job.threads.size.should > 1
+        expect(job.threads.size).to be > 1
       end
     end
 
@@ -393,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
@@ -416,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
 
@@ -439,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
 
@@ -466,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
@@ -498,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
@@ -518,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
@@ -542,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
@@ -557,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
@@ -571,7 +571,7 @@ describe Rufus::Scheduler::Job do
 
       sleep 3
 
-      counter.should > 1
+      expect(counter).to be > 1
     end
   end
 
@@ -583,7 +583,7 @@ describe Rufus::Scheduler::Job do
 
         job = @scheduler.schedule_every '5m' do; end
 
-        job.last_work_time.should == 0.0
+        expect(job.last_work_time).to eq(0.0)
       end
 
       it 'keeps track of how long the work was upon last trigger' do
@@ -595,8 +595,8 @@ describe Rufus::Scheduler::Job do
 
         sleep 2
 
-        job.last_work_time.should >= 0.7
-        job.last_work_time.should < 0.8
+        expect(job.last_work_time).to be >= 0.7
+        expect(job.last_work_time).to be < 0.8
       end
     end
 
@@ -606,7 +606,7 @@ describe Rufus::Scheduler::Job do
 
         job = @scheduler.schedule_every '5m' do; end
 
-        job.mean_work_time.should == 0.0
+        expect(job.mean_work_time).to eq(0.0)
       end
 
       it 'gathers work times and computes the mean' do
@@ -620,10 +620,10 @@ describe Rufus::Scheduler::Job do
 
         sleep 4.6
 
-        job.last_work_time.should >= 0.08
-        job.last_work_time.should < 0.099
-        job.mean_work_time.should > 0.05
-        job.mean_work_time.should < 0.06
+        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

data/spec/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/parse_spec.rb

@@ -12,70 +12,112 @@ describe Rufus::Scheduler do
 
   describe '.parse' do
 
-    def parse(s)
-      Rufus::Scheduler.parse(s)
+    def parse(s, opts={})
+      Rufus::Scheduler.parse(s, opts)
     end
 
     it 'parses duration strings' do
 
-      parse('1.0d1.0w1.0d').should == 777600.0
+      expect(parse('1.0d1.0w1.0d')).to eq(777600.0)
     end
 
     it 'parses datetimes' do
 
       # local
 
-      parse('Sun Nov 18 16:01:00 2012').strftime('%c').should ==
+      expect(parse('Sun Nov 18 16:01:00 2012').strftime('%c')).to eq(
         'Sun Nov 18 16:01:00 2012'
+      )
     end
 
     it 'parses datetimes with timezones' do
 
-      parse('Sun Nov 18 16:01:00 2012 Japan').getutc.strftime('%c').should ==
+      expect(parse('Sun Nov 18 16:01:00 2012 Japan').getutc.strftime('%c')).to eq(
         'Sun Nov 18 07:01:00 2012'
+      )
 
-      parse('Sun Nov 18 16:01:00 2012 Zulu').getutc.strftime('%c').should ==
+      expect(parse('Sun Nov 18 16:01:00 2012 Zulu').getutc.strftime('%c')).to eq(
         'Sun Nov 18 16:01:00 2012'
+      )
 
-      parse('Sun Nov 18 16:01:00 Japan 2012').getutc.strftime('%c').should ==
+      expect(parse('Sun Nov 18 16:01:00 Japan 2012').getutc.strftime('%c')).to eq(
         'Sun Nov 18 07:01:00 2012'
+      )
 
-      parse('Japan Sun Nov 18 16:01:00 2012').getutc.strftime('%c').should ==
+      expect(parse('Japan Sun Nov 18 16:01:00 2012').getutc.strftime('%c')).to eq(
         'Sun Nov 18 07:01:00 2012'
+      )
     end
 
     it 'parses datetimes with named timezones' do
 
-      parse(
+      expect(parse(
         'Sun Nov 18 16:01:00 2012 Europe/Berlin'
-      ).strftime('%c %z').should ==
+      ).strftime('%c %z')).to eq(
         'Sun Nov 18 15:01:00 2012 +0000'
+      )
     end
 
     it 'parses datetimes (with the local timezone implicitely)' do
 
       localzone = Time.now.strftime('%z')
 
-      parse('Sun Nov 18 16:01:00 2012').strftime('%c %z').should ==
+      expect(parse('Sun Nov 18 16:01:00 2012').strftime('%c %z')).to eq(
         "Sun Nov 18 16:01:00 2012 #{localzone}"
+      )
     end
 
     it 'parses cronlines' do
 
       out = parse('* * * * *')
 
-      out.class.should == Rufus::Scheduler::CronLine
-      out.original.should == '* * * * *'
+      expect(out.class).to eq(Rufus::Scheduler::CronLine)
+      expect(out.original).to eq('* * * * *')
 
-      parse('10 23 * * *').class.should == Rufus::Scheduler::CronLine
-      parse('* 23 * * *').class.should == Rufus::Scheduler::CronLine
+      expect(parse('10 23 * * *').class).to eq(Rufus::Scheduler::CronLine)
+      expect(parse('* 23 * * *').class).to eq(Rufus::Scheduler::CronLine)
     end
 
     it 'raises on unparseable input' do
 
-      lambda {
+      expect {
         parse('nada')
-      }.should raise_error(ArgumentError, 'couldn\'t parse "nada"')
+      }.to raise_error(ArgumentError, 'couldn\'t parse "nada"')
+    end
+
+    it 'does not use Chronic if not present' do
+
+      t = parse('next monday 7 PM')
+
+      n = Time.now
+
+      expect(t.strftime('%Y-%m-%d %H:%M:%S')).to eq(
+        n.strftime('%Y-%m-%d') + ' 19:00:00'
+      )
+    end
+
+    it 'uses Chronic if present' do
+
+      with_chronic do
+
+        t = parse('next monday 7 PM')
+
+        expect(t.wday).to eq(1)
+        expect(t.hour).to eq(19)
+        expect(t.min).to eq(0)
+        expect(t).to be > Time.now
+      end
+    end
+
+    it 'passes options to Chronic' do
+
+      with_chronic do
+
+        t = parse('monday', :context => :past)
+
+        expect(t.wday).to eq(1)
+        expect(t).to be < Time.now
+      end
     end
   end
 
@@ -87,54 +129,54 @@ describe Rufus::Scheduler do
 
     it 'parses duration strings' do
 
-      pd('-1.0d1.0w1.0d').should == -777600.0
-      pd('-1d1w1d').should == -777600.0
-      pd('-1w2d').should == -777600.0
-      pd('-1h10s').should == -3610.0
-      pd('-1h').should == -3600.0
-      pd('-5.').should == -5.0
-      pd('-2.5s').should == -2.5
-      pd('-1s').should == -1.0
-      pd('-500').should == -500
-      pd('').should == 0.0
-      pd('5.0').should == 5.0
-      pd('0.5').should == 0.5
-      pd('.5').should == 0.5
-      pd('5.').should == 5.0
-      pd('500').should == 500
-      pd('1000').should == 1000
-      pd('1').should == 1.0
-      pd('1s').should == 1.0
-      pd('2.5s').should == 2.5
-      pd('1h').should == 3600.0
-      pd('1h10s').should == 3610.0
-      pd('1w2d').should == 777600.0
-      pd('1d1w1d').should == 777600.0
-      pd('1.0d1.0w1.0d').should == 777600.0
-
-      pd('.5m').should == 30.0
-      pd('5.m').should == 300.0
-      pd('1m.5s').should == 60.5
-      pd('-.5m').should == -30.0
-
-      pd('1').should == 1
-      pd('0.1').should == 0.1
-      pd('1s').should == 1
+      expect(pd('-1.0d1.0w1.0d')).to eq(-777600.0)
+      expect(pd('-1d1w1d')).to eq(-777600.0)
+      expect(pd('-1w2d')).to eq(-777600.0)
+      expect(pd('-1h10s')).to eq(-3610.0)
+      expect(pd('-1h')).to eq(-3600.0)
+      expect(pd('-5.')).to eq(-5.0)
+      expect(pd('-2.5s')).to eq(-2.5)
+      expect(pd('-1s')).to eq(-1.0)
+      expect(pd('-500')).to eq(-500)
+      expect(pd('')).to eq(0.0)
+      expect(pd('5.0')).to eq(5.0)
+      expect(pd('0.5')).to eq(0.5)
+      expect(pd('.5')).to eq(0.5)
+      expect(pd('5.')).to eq(5.0)
+      expect(pd('500')).to eq(500)
+      expect(pd('1000')).to eq(1000)
+      expect(pd('1')).to eq(1.0)
+      expect(pd('1s')).to eq(1.0)
+      expect(pd('2.5s')).to eq(2.5)
+      expect(pd('1h')).to eq(3600.0)
+      expect(pd('1h10s')).to eq(3610.0)
+      expect(pd('1w2d')).to eq(777600.0)
+      expect(pd('1d1w1d')).to eq(777600.0)
+      expect(pd('1.0d1.0w1.0d')).to eq(777600.0)
+
+      expect(pd('.5m')).to eq(30.0)
+      expect(pd('5.m')).to eq(300.0)
+      expect(pd('1m.5s')).to eq(60.5)
+      expect(pd('-.5m')).to eq(-30.0)
+
+      expect(pd('1')).to eq(1)
+      expect(pd('0.1')).to eq(0.1)
+      expect(pd('1s')).to eq(1)
     end
 
     it 'calls #to_s on its input' do
 
-      pd(0.1).should == 0.1
+      expect(pd(0.1)).to eq(0.1)
     end
 
     it 'raises on wrong duration strings' do
 
-      lambda { pd('-') }.should raise_error(ArgumentError)
-      lambda { pd('h') }.should raise_error(ArgumentError)
-      lambda { pd('whatever') }.should raise_error(ArgumentError)
-      lambda { pd('hms') }.should raise_error(ArgumentError)
+      expect { pd('-') }.to raise_error(ArgumentError)
+      expect { pd('h') }.to raise_error(ArgumentError)
+      expect { pd('whatever') }.to raise_error(ArgumentError)
+      expect { pd('hms') }.to raise_error(ArgumentError)
 
-      lambda { pd(' 1h ') }.should raise_error(ArgumentError)
+      expect { pd(' 1h ') }.to raise_error(ArgumentError)
     end
   end
 
@@ -142,7 +184,7 @@ describe Rufus::Scheduler do
 
     it 'is still around for libs using it out there' do
 
-      Rufus::Scheduler.parse_time_string('1d1w1d').should == 777600.0
+      expect(Rufus::Scheduler.parse_time_string('1d1w1d')).to eq(777600.0)
     end
   end
 
@@ -150,7 +192,7 @@ describe Rufus::Scheduler do
 
     it 'is still around for libs using it out there' do
 
-      Rufus::Scheduler.parse_duration_string('1d1w1d').should == 777600.0
+      expect(Rufus::Scheduler.parse_duration_string('1d1w1d')).to eq(777600.0)
     end
   end
 
@@ -162,32 +204,32 @@ describe Rufus::Scheduler do
 
     it 'turns integers into duration strings' do
 
-      td(0).should == '0s'
-      td(60).should == '1m'
-      td(61).should == '1m1s'
-      td(3661).should == '1h1m1s'
-      td(24 * 3600).should == '1d'
-      td(7 * 24 * 3600 + 1).should == '1w1s'
-      td(30 * 24 * 3600 + 1).should == '4w2d1s'
+      expect(td(0)).to eq('0s')
+      expect(td(60)).to eq('1m')
+      expect(td(61)).to eq('1m1s')
+      expect(td(3661)).to eq('1h1m1s')
+      expect(td(24 * 3600)).to eq('1d')
+      expect(td(7 * 24 * 3600 + 1)).to eq('1w1s')
+      expect(td(30 * 24 * 3600 + 1)).to eq('4w2d1s')
     end
 
     it 'ignores seconds and milliseconds if :drop_seconds => true' do
 
-      td(0, :drop_seconds => true).should == '0m'
-      td(5, :drop_seconds => true).should == '0m'
-      td(61, :drop_seconds => true).should == '1m'
+      expect(td(0, :drop_seconds => true)).to eq('0m')
+      expect(td(5, :drop_seconds => true)).to eq('0m')
+      expect(td(61, :drop_seconds => true)).to eq('1m')
     end
 
     it 'displays months if :months => true' do
 
-      td(1, :months => true).should == '1s'
-      td(30 * 24 * 3600 + 1, :months => true).should == '1M1s'
+      expect(td(1, :months => true)).to eq('1s')
+      expect(td(30 * 24 * 3600 + 1, :months => true)).to eq('1M1s')
     end
 
     it 'turns floats into duration strings' do
 
-      td(0.1).should == '100'
-      td(1.1).should == '1s100'
+      expect(td(0.1)).to eq('100')
+      expect(td(1.1)).to eq('1s100')
     end
   end
 
@@ -199,20 +241,20 @@ describe Rufus::Scheduler do
 
     it 'turns integers duration hashes' do
 
-      tdh(0).should == {}
-      tdh(60).should == { :m => 1 }
+      expect(tdh(0)).to eq({})
+      expect(tdh(60)).to eq({ :m => 1 })
     end
 
     it 'turns floats duration hashes' do
 
-      tdh(0.128).should == { :ms => 128 }
-      tdh(60.127).should == { :m => 1, :ms => 127 }
+      expect(tdh(0.128)).to eq({ :ms => 128 })
+      expect(tdh(60.127)).to eq({ :m => 1, :ms => 127 })
     end
 
     it 'drops seconds and milliseconds if :drop_seconds => true' do
 
-      tdh(61.127).should == { :m => 1, :s => 1, :ms => 127 }
-      tdh(61.127, :drop_seconds => true).should == { :m => 1 }
+      expect(tdh(61.127)).to eq({ :m => 1, :s => 1, :ms => 127 })
+      expect(tdh(61.127, :drop_seconds => true)).to eq({ :m => 1 })
     end
   end
 end