rufus-scheduler 3.0.0 → 3.0.9

data/spec/error_spec.rb

@@ -43,8 +43,8 @@ describe Rufus::Scheduler do
 
       sleep 2
 
-      counter.should > 2
-      $stderr.string.should match(/argh/)
+      expect(counter).to be > 2
+      expect($stderr.string).to match(/argh/)
     end
   end
 
@@ -69,8 +69,8 @@ describe Rufus::Scheduler do
 
       sleep 2
 
-      mfh.counter.should > 2
-      $stderr.string.should match(/ouch/)
+      expect(mfh.counter).to be > 2
+      expect($stderr.string).to match(/ouch/)
     end
   end
 
@@ -86,8 +86,31 @@ describe Rufus::Scheduler do
 
       sleep 0.5
 
-      @scheduler.stderr.string.should match(/intercepted an error/)
-      @scheduler.stderr.string.should match(/miserably/)
+      expect(@scheduler.stderr.string).to match(/intercepted an error/)
+      expect(@scheduler.stderr.string).to match(/miserably/)
+    end
+  end
+
+  context 'error information' do
+
+    it 'contains information about the error, the job and the scheduler' do
+
+      @scheduler.stderr = StringIO.new
+
+      @scheduler.in('0s') do
+        fail 'miserably'
+      end
+
+      sleep 0.5
+
+      s = @scheduler.stderr.string
+      #puts s
+
+      expect(s).to match(/ENV\['TZ'\]:/)
+      expect(s).to match(/down\?: false/)
+      expect(s).to match(/work_threads: 1/)
+      expect(s).to match(/running_jobs: 1/)
+      expect(s).to match(/uptime: \d/)
     end
   end
 
@@ -109,7 +132,7 @@ describe Rufus::Scheduler do
 
       sleep 0.5
 
-      $message.should == 'Rufus::Scheduler::InJob 0s miserably'
+      expect($message).to eq('Rufus::Scheduler::InJob 0s miserably')
     end
   end
 end

data/spec/job_array_spec.rb

@@ -22,7 +22,7 @@ describe Rufus::Scheduler::JobArray do
 
       @array.push(DummyJob.new('a', Time.local(0)))
 
-      @array.to_a.collect(&:id).should == %w[ a ]
+      expect(@array.to_a.collect(&:id)).to eq(%w[ a ])
     end
 
     it 'pushes and remove duplicates' do
@@ -32,7 +32,7 @@ describe Rufus::Scheduler::JobArray do
       @array.push(j)
       @array.push(j)
 
-      @array.to_a.collect(&:id).should == %w[ a ]
+      expect(@array.to_a.collect(&:id)).to eq(%w[ a ])
     end
   end
 end

data/spec/job_at_spec.rb

@@ -28,7 +28,7 @@ describe Rufus::Scheduler::AtJob do
 
       sleep 0.4
 
-      @scheduler.jobs.size.should == 0
+      expect(@scheduler.jobs.size).to eq(0)
     end
   end
 
@@ -38,8 +38,8 @@ describe Rufus::Scheduler::AtJob do
 
       job = @scheduler.schedule_at((t = Time.now) + 3600) {}
 
-      job.scheduled_at.to_i.should >= t.to_i - 1
-      job.scheduled_at.to_i.should <= t.to_i + 1
+      expect(job.scheduled_at.to_i).to be >= t.to_i - 1
+      expect(job.scheduled_at.to_i).to be <= t.to_i + 1
     end
   end
 
@@ -51,7 +51,7 @@ describe Rufus::Scheduler::AtJob do
 
       job = @scheduler.schedule_at t do; end
 
-      job.time.should == t
+      expect(job.time).to eq(t)
     end
   end
 end

data/spec/job_cron_spec.rb

@@ -25,7 +25,7 @@ describe Rufus::Scheduler::CronJob do
 
       sleep_until_next_minute
 
-      (job.last_time.to_i % 10).should == 0
+      expect(job.last_time.to_i % 10).to eq(0)
     end
   end
 
@@ -59,8 +59,47 @@ describe Rufus::Scheduler::CronJob do
       #p [ job.last_time, job.last_time.to_f ]
       #p [ job.first_at, job.first_at.to_f ]
 
-      job.first_at.should be_within_1s_of(t + 3)
-      job.last_time.should == nil
+      expect(job.first_at).to be_within_1s_of(t + 3)
+      expect(job.last_time).to eq(nil)
+    end
+
+    it 'triggers for the first time at first_at' do
+
+      first_time = nil
+      t = Time.now
+
+      job = @scheduler.schedule_cron '* * * * * *', :first_in => '3s' do
+        first_time ||= Time.now
+      end
+      sleep 4.5
+
+      expect(job.first_at).to be_within_1s_of(t + 3)
+      expect(first_time).to be_within_1s_of(job.first_at)
+    end
+  end
+
+  context 'scheduling the cron itself' do
+
+    # for https://github.com/jmettraux/rufus-scheduler/issues/95
+    #
+    # schedule_cron takes more than 30 seconds, blocking...
+    #
+    it 'does not sit scheduling and blocking...' do
+
+      n = Time.now
+      first = nil
+
+      job = @scheduler.schedule_cron '*/2 * * * * *' do
+        first ||= Time.now
+      end
+
+      expect(Time.now - n).to be < 1.0
+
+      loop do
+        next unless first
+        expect(first - n).to be < 4.0
+        break
+      end
     end
   end
 end

data/spec/job_every_spec.rb

@@ -27,7 +27,26 @@ describe Rufus::Scheduler::EveryJob do
 
     sleep 3.5
 
-    [ 2, 3 ].should include(counter)
+    expect([ 2, 3 ]).to include(counter)
+  end
+
+  it 'lets its @next_time change in-flight' do
+
+    times = []
+
+    @scheduler.every '1s' do |job|
+      times << Time.now
+      job.next_time = Time.now + 3 if times.count == 2
+    end
+
+    sleep 0.3 while times.count < 3
+
+    #p [ times[1] - times[0], times[2] - times[1] ]
+
+    expect(times[1] - times[0]).to be > 1.0
+    expect(times[1] - times[0]).to be < 1.4
+    expect(times[2] - times[1]).to be > 3.0
+    expect(times[2] - times[1]).to be < 3.4
   end
 
   context 'first_at/in' do
@@ -44,8 +63,8 @@ describe Rufus::Scheduler::EveryJob do
       #p [ job.last_time, job.last_time.to_f ]
       #p [ job.first_at, job.first_at.to_f ]
 
-      job.first_at.should be_within_1s_of(t + 2)
-      job.last_time.should be_within_1s_of(job.first_at)
+      expect(job.first_at).to be_within_1s_of(t + 2)
+      expect(job.last_time).to be_within_1s_of(job.first_at)
     end
 
     describe '#first_at=' do
@@ -62,8 +81,8 @@ describe Rufus::Scheduler::EveryJob do
         fa1 = job.first_at
         nt1 = job.next_time
 
-        nt0.should == fa0
-        nt1.should == fa1
+        expect(nt0).to eq(fa0)
+        expect(nt1).to eq(fa1)
       end
     end
   end

data/spec/job_interval_spec.rb

@@ -23,7 +23,7 @@ describe Rufus::Scheduler::IntervalJob do
 
       job = @scheduler.schedule_interval('1h') do; end
 
-      job.interval.should == 3600
+      expect(job.interval).to eq(3600)
     end
   end
 
@@ -41,8 +41,8 @@ describe Rufus::Scheduler::IntervalJob do
       #p [ job.last_time, job.last_time.to_f ]
       #p [ job.first_at, job.first_at.to_f ]
 
-      job.first_at.should be_within_1s_of(t + 2)
-      job.last_time.should be_within_1s_of(job.first_at)
+      expect(job.first_at).to be_within_1s_of(t + 2)
+      expect(job.last_time).to be_within_1s_of(job.first_at)
     end
 
     describe '#first_at=' do
@@ -59,8 +59,8 @@ describe Rufus::Scheduler::IntervalJob do
         fa1 = job.first_at
         nt1 = job.next_time
 
-        nt0.should == fa0
-        nt1.should == fa1
+        expect(nt0).to eq(fa0)
+        expect(nt1).to eq(fa1)
       end
     end
   end

data/spec/job_repeat_spec.rb

@@ -28,7 +28,7 @@ describe Rufus::Scheduler::RepeatJob do
           counter += 1
         end
 
-      counter.should == 0
+      expect(counter).to eq(0)
 
       while counter < 1; sleep(0.1); end
 
@@ -36,7 +36,7 @@ describe Rufus::Scheduler::RepeatJob do
 
       sleep(1)
 
-      counter.should == 1
+      expect(counter).to eq(1)
     end
   end
 
@@ -48,14 +48,14 @@ describe Rufus::Scheduler::RepeatJob do
 
       job.pause
 
-      job.paused?.should == true
+      expect(job.paused?).to eq(true)
     end
 
     it 'returns false if the job is not paused' do
 
       job = @scheduler.schedule_every('10s') do; end
 
-      job.paused?.should == false
+      expect(job.paused?).to eq(false)
     end
   end
 
@@ -75,7 +75,7 @@ describe Rufus::Scheduler::RepeatJob do
 
       sleep(1.5)
 
-      counter.should > 1
+      expect(counter).to be > 1
     end
 
     it 'has no effect on a not paused job' do
@@ -84,7 +84,7 @@ describe Rufus::Scheduler::RepeatJob do
 
       job.resume
 
-      job.paused?.should == false
+      expect(job.paused?).to eq(false)
     end
   end
 
@@ -101,7 +101,7 @@ describe Rufus::Scheduler::RepeatJob do
 
       sleep(2.6)
 
-      counter.should == 3
+      expect(counter).to eq(3)
     end
 
     it 'is OK when passed a nil instead of an integer' do
@@ -115,14 +115,14 @@ describe Rufus::Scheduler::RepeatJob do
 
       sleep(2.5)
 
-      counter.should > 3
+      expect(counter).to be > 3
     end
 
     it 'raises when passed something else than nil or an integer' do
 
-      lambda {
+      expect {
         @scheduler.schedule_every '0.5s', :times => 'nada' do; end
-      }.should raise_error(ArgumentError)
+      }.to raise_error(ArgumentError)
     end
   end
 
@@ -134,7 +134,7 @@ describe Rufus::Scheduler::RepeatJob do
 
       job = @scheduler.schedule_every '0.5s', :first => t do; end
 
-      job.first_at.should == t
+      expect(job.first_at).to eq(t)
     end
 
     it 'accepts a time string' do
@@ -143,8 +143,8 @@ describe Rufus::Scheduler::RepeatJob do
 
       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
+      expect(job.first_at.to_s).to eq(t.to_s)
+      expect(job.first_at.zone).to eq(t.zone)
     end
 
     it 'only lets the job trigger after the :first' do
@@ -159,20 +159,43 @@ describe Rufus::Scheduler::RepeatJob do
 
       sleep(1)
 
-      counter.should == 0
+      expect(counter).to eq(0)
 
       sleep(1)
 
-      counter.should > 0
+      expect(counter).to be > 0
     end
 
     it 'raises on points in the past' do
 
-      lambda {
+      expect {
 
         @scheduler.schedule_every '0.5s', :first => Time.now - 60 do; end
 
-      }.should raise_error(ArgumentError)
+      }.to raise_error(ArgumentError)
+    end
+
+    context ':first_time => :now/:immediately' do
+
+      it 'schedules the first execution immediately' do
+
+        n = Time.now
+        ft = nil
+
+        job =
+          @scheduler.schedule_every '7s', :first => :now do
+            ft ||= Time.now
+          end
+
+        sleep 0.7
+
+        #p n.to_f
+        #p job.first_at.to_f
+        #p ft.to_f
+
+        expect(job.first_at).to be < n + 0.7
+        expect(ft).to be < job.first_at + @scheduler.frequency + 0.1
+      end
     end
   end
 
@@ -184,8 +207,8 @@ describe Rufus::Scheduler::RepeatJob do
 
       job = @scheduler.schedule_every '0.5s', :first => '1h' do; end
 
-      job.first_at.should >= t + 3600
-      job.first_at.should < t + 3601
+      expect(job.first_at).to be >= t + 3600
+      expect(job.first_at).to be < t + 3601
     end
 
     it 'accepts a duration in seconds (integer)' do
@@ -194,15 +217,15 @@ describe Rufus::Scheduler::RepeatJob do
 
       job = @scheduler.schedule_every '0.5s', :first => 3600 do; end
 
-      job.first_at.should >= t + 3600
-      job.first_at.should < t + 3601
+      expect(job.first_at).to be >= t + 3600
+      expect(job.first_at).to be < t + 3601
     end
 
     it 'raises if the argument cannot be used' do
 
-      lambda {
+      expect {
         @scheduler.every '0.5s', :first => :nada do; end
-      }.should raise_error(ArgumentError)
+      }.to raise_error(ArgumentError)
     end
   end
 
@@ -213,7 +236,7 @@ describe Rufus::Scheduler::RepeatJob 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'
+      expect(job.first_at.strftime('%c')).to eq('Thu Dec 12 12:00:30 2030')
     end
   end
 
@@ -225,23 +248,28 @@ describe Rufus::Scheduler::RepeatJob do
 
       job = @scheduler.schedule_every '0.5s', :last => t do; end
 
-      job.last_at.should == t
+      expect(job.last_at).to eq(t)
     end
 
     it 'unschedules the job after the last_at time' do
 
       t = Time.now + 2
+
       counter = 0
+      tt = nil
 
       job =
         @scheduler.schedule_every '0.5s', :last => t do
           counter = counter + 1
+          tt = Time.now
         end
 
       sleep 3
 
-      counter.should == 3
-      @scheduler.jobs.should_not include(job)
+      #counter.should == 3
+      expect([ 3, 4 ]).to include(counter)
+      expect(tt).to be < t
+      expect(@scheduler.jobs).not_to include(job)
     end
 
     it 'accepts a time string' do
@@ -250,17 +278,17 @@ describe Rufus::Scheduler::RepeatJob do
 
       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
+      expect(job.last_at.to_s).to eq(t.to_s)
+      expect(job.last_at.zone).to eq(t.zone)
     end
 
     it 'raises on a point in the past' do
 
-      lambda {
+      expect {
 
         @scheduler.every '0.5s', :last => Time.now - 60 do; end
 
-      }.should raise_error(ArgumentError)
+      }.to raise_error(ArgumentError)
     end
   end
 
@@ -272,8 +300,8 @@ describe Rufus::Scheduler::RepeatJob do
 
       job = @scheduler.schedule_every '0.5s', :last_in => '2s' do; end
 
-      job.last_at.should >= t + 2
-      job.last_at.should < t + 2.5
+      expect(job.last_at).to be >= t + 2
+      expect(job.last_at).to be < t + 2.5
     end
 
     it 'accepts a duration in seconds (integer)' do
@@ -282,15 +310,15 @@ describe Rufus::Scheduler::RepeatJob do
 
       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
+      expect(job.last_at).to be >= t + 2
+      expect(job.last_at).to be < t + 2.5
     end
 
     it 'raises if the argument is worthless' do
 
-      lambda {
+      expect {
         @scheduler.every '0.5s', :last => :nada do; end
-      }.should raise_error(ArgumentError)
+      }.to raise_error(ArgumentError)
     end
   end
 
@@ -301,7 +329,27 @@ describe Rufus::Scheduler::RepeatJob 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'
+      expect(job.last_at.strftime('%c')).to eq('Thu Dec 12 12:00:30 2030')
+    end
+  end
+
+  describe '#count' do
+
+    it 'starts at 0' do
+
+      job = @scheduler.schedule_every '5m' do; end
+
+      expect(job.count).to eq(0)
+    end
+
+    it 'keeps track of how many times the job fired' do
+
+      job = @scheduler.schedule_every '0.5s' do; end
+
+      sleep(2.0)
+
+      expect(job.count).to be >= 3
+      expect(job.count).to be <= 4
     end
   end
 end