rufus-scheduler 3.1.9 → 3.1.10

data/spec/job_in_spec.rb

@@ -1,20 +0,0 @@
-
-#
-# Specifying rufus-scheduler
-#
-# Wed Apr 17 06:00:59 JST 2013
-#
-
-require 'spec_helper'
-
-
-describe Rufus::Scheduler::InJob do
-
-  before :each do
-    @scheduler = Rufus::Scheduler.new
-  end
-  after :each do
-    @scheduler.shutdown
-  end
-end
-

data/spec/job_interval_spec.rb

@@ -1,68 +0,0 @@
-
-#
-# Specifying rufus-scheduler
-#
-# Wed Apr 17 06:00:59 JST 2013
-#
-
-require 'spec_helper'
-
-
-describe Rufus::Scheduler::IntervalJob do
-
-  before :each do
-    @scheduler = Rufus::Scheduler.new
-  end
-  after :each do
-    @scheduler.shutdown
-  end
-
-  describe '#interval' do
-
-    it 'returns the scheduled interval' do
-
-      job = @scheduler.schedule_interval('1h') do; end
-
-      expect(job.interval).to eq(3600)
-    end
-  end
-
-  context 'first_at/in' do
-
-    it 'triggers for the first time at first_at' do
-
-      t = Time.now
-
-      job = @scheduler.schedule_interval '3s', :first_in => '1s' do; end
-
-      sleep 2
-
-      #p [ t, t.to_f ]
-      #p [ job.last_time, job.last_time.to_f ]
-      #p [ job.first_at, job.first_at.to_f ]
-
-      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
-
-      it 'alters @next_time' do
-
-        job = @scheduler.schedule_interval '3s', :first_in => '10s' do; end
-
-        fa0 = job.first_at
-        nt0 = job.next_time
-
-        job.first_at = Time.now + 3
-
-        fa1 = job.first_at
-        nt1 = job.next_time
-
-        expect(nt0).to eq(fa0)
-        expect(nt1).to eq(fa1)
-      end
-    end
-  end
-end
-

data/spec/job_repeat_spec.rb

@@ -1,357 +0,0 @@
-
-#
-# 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
-
-      expect(counter).to eq(0)
-
-      while counter < 1; sleep(0.1); end
-
-      job.pause
-
-      sleep(1)
-
-      expect(counter).to eq(1)
-    end
-  end
-
-  describe '#paused?' do
-
-    it 'returns true if the job is paused' do
-
-      job = @scheduler.schedule_every('10s') do; end
-
-      job.pause
-
-      expect(job.paused?).to eq(true)
-    end
-
-    it 'returns false if the job is not paused' do
-
-      job = @scheduler.schedule_every('10s') do; end
-
-      expect(job.paused?).to eq(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)
-
-      expect(counter).to be > 1
-    end
-
-    it 'has no effect on a not paused job' do
-
-      job = @scheduler.schedule_every('10s') do; end
-
-      job.resume
-
-      expect(job.paused?).to eq(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)
-
-      expect(counter).to eq(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)
-
-      expect(counter).to be > 3
-    end
-
-    it 'raises when passed something else than nil or an integer' do
-
-      expect {
-        @scheduler.schedule_every '0.5s', :times => 'nada' do; end
-      }.to 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
-
-      expect(job.first_at).to eq(t)
-    end
-
-    it 'accepts a time string' do
-
-      t = Time.now + 10
-
-      job = @scheduler.schedule_every '0.5s', :first => t.to_s do; end
-
-      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
-
-      t = Time.now + 1.4
-      counter = 0
-
-      job =
-        @scheduler.schedule_every '0.5s', :first => t do
-          counter = counter + 1
-        end
-
-      sleep(1)
-
-      expect(counter).to eq(0)
-
-      sleep(1)
-
-      expect(counter).to be > 0
-    end
-
-    it 'raises on points in the past' do
-
-      expect {
-
-        @scheduler.schedule_every '0.5s', :first => Time.now - 60 do; end
-
-      }.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 Time.now.to_f
-        #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
-
-  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
-
-      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
-
-      t = Time.now
-
-      job = @scheduler.schedule_every '0.5s', :first => 3600 do; end
-
-      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
-
-      expect {
-        @scheduler.every '0.5s', :first => :nada do; end
-      }.to 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'
-
-      expect(job.first_at.strftime('%c')).to eq('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
-
-      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
-      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
-
-      t = Time.now + 10
-
-      job = @scheduler.schedule_every '0.5s', :last => t.to_s do; end
-
-      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
-
-      expect {
-
-        @scheduler.every '0.5s', :last => Time.now - 60 do; end
-
-      }.to 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
-
-      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
-
-      t = Time.now
-
-      job = @scheduler.schedule_every '0.5s', :last_in => 2.0 do; end
-
-      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
-
-      expect {
-        @scheduler.every '0.5s', :last => :nada do; end
-      }.to 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'
-
-      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
-

data/spec/job_spec.rb

@@ -1,671 +0,0 @@
-
-#
-# Specifying rufus-scheduler
-#
-# Wed Apr 17 06:00:59 JST 2013
-#
-
-require 'spec_helper'
-
-
-describe Rufus::Scheduler::Job do
-
-  # 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
-
-    @scheduler.shutdown
-
-    Thread.abort_on_exception = @taoe
-
-    $stderr = @ose
-  end
-
-  describe '#last_time' do
-
-    it 'returns nil if the job never fired' do
-
-      job = @scheduler.schedule_in '10d' do; end
-
-      expect(job.last_time).to eq(nil)
-    end
-
-    it 'returns the last time the job fired' do
-
-      job = @scheduler.schedule_in '0s' do; end
-
-      sleep 0.4
-
-      expect(job.last_time).not_to eq(nil)
-    end
-  end
-
-  describe '#threads' do
-
-    it 'returns an empty list when the job is not running' do
-
-      job = @scheduler.in('1d', :job => true) {}
-
-      expect(job.threads.size).to eq(0)
-    end
-
-    it 'returns an empty list after the job terminated' do
-
-      job = @scheduler.in('0s', :job => true) {}
-
-      sleep 0.8
-
-      expect(job.threads.size).to eq(0)
-    end
-
-    it 'lists the threads the job currently runs in' do
-
-      job =
-        @scheduler.schedule_in('0s') do
-          sleep(1)
-        end
-
-      sleep 0.4
-
-      expect(job.threads.size).to eq(1)
-
-      t = job.threads.first
-      expect(t[:rufus_scheduler_job]).to eq(job)
-    end
-  end
-
-  describe '#kill' do
-
-    it 'has no effect if the job is not running' do
-
-      job = @scheduler.schedule_in '10d' do; end
-
-      tls = Thread.list.size
-
-      job.kill
-
-      expect(Thread.list.size).to eq(tls)
-    end
-
-    it 'makes the threads vacant' do
-
-      counter = 0
-
-      job =
-        @scheduler.schedule_in '0s' do
-          sleep 2
-          counter = counter + 1
-        end
-
-      sleep 1
-
-      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
-
-      expect(counter).to eq(0)
-
-      expect(v0).to eq(0)
-      expect(a0).to eq(1)
-
-      expect(v1).to eq(1)
-      expect(a1).to eq(0)
-    end
-  end
-
-  describe '#running?' do
-
-    it 'returns false when the job is not running in any thread' do
-
-      job = @scheduler.in('1d', :job => true) {}
-
-      expect(job.running?).to eq(false)
-    end
-
-    it 'returns true when the job is running in at least one thread' do
-
-      job = @scheduler.in('0s', :job => true) { sleep(1) }
-
-      sleep 0.4
-
-      expect(job.running?).to eq(true)
-    end
-  end
-
-  describe '#scheduled?' do
-
-    it 'returns true when the job is scheduled' do
-
-      job = @scheduler.schedule_in('1d') {}
-
-      expect(job.scheduled?).to eq(true)
-    end
-
-    it 'returns false when the job is not scheduled' do
-
-      job = @scheduler.schedule_in('0.1s') {}
-
-      sleep 0.4
-
-      expect(job.scheduled?).to eq(false)
-    end
-
-    it 'returns true for repeat jobs that are running' do
-
-      job = @scheduler.schedule_interval('0.4s') { sleep(10) }
-
-      sleep 1
-
-      expect(job.running?).to eq(true)
-      expect(job.scheduled?).to eq(true)
-    end
-
-    it 'returns false if job is unscheduled' do
-      job = @scheduler.schedule_interval('0.1s') { sleep 0.1 }
-      job.unschedule
-
-      sleep 0.3
-
-      expect(job.running?).to eq(false)
-      expect(job.scheduled?).to eq(false)
-    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
-
-  context 'job-local variables' do
-
-    describe '#[]=' do
-
-      it 'sets a job-local variable' do
-
-        job =
-          @scheduler.schedule_every '1s' do |job|
-            job[:counter] ||= 0
-            job[:counter] += 1
-          end
-
-        sleep 3
-
-        expect(job[:counter]).to be > 1
-      end
-    end
-
-    describe '#[]' do
-
-      it 'returns nil if there is no such entry' do
-
-        job = @scheduler.schedule_in '1s' do; end
-
-        expect(job[:nada]).to eq(nil)
-      end
-
-      it 'returns the value of a job-local variable' do
-
-        job = @scheduler.schedule_in '1s' do; end
-        job[:x] = :y
-
-        expect(job[:x]).to eq(:y)
-      end
-    end
-
-    describe '#key?' do
-
-      it 'returns true if there is an entry with the given key' do
-
-        job = @scheduler.schedule_in '1s' do; end
-        job[:x] = :y
-
-        expect(job.key?(:x)).to eq(true)
-      end
-    end
-
-    describe '#keys' do
-
-      it 'returns the array of keys of the job-local variables' do
-
-        job = @scheduler.schedule_in '1s' do; end
-        job[:x] = :y
-        job['hello'] = :z
-        job[123] = {}
-
-        expect(job.keys.sort_by { |k| k.to_s }).to eq([ 123, 'hello', :x ])
-      end
-    end
-  end
-
-  context ':tag / :tags => [ t0, t1 ]' do
-
-    it 'accepts one tag' do
-
-      job = @scheduler.in '10d', :job => true, :tag => 't0' do; end
-
-      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
-
-      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
-
-      expect(job.tags).to eq(%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
-
-      sleep 0.4
-
-      expect(job.threads.first).to eq(@scheduler.thread)
-
-      sleep 1.4
-
-      expect(job.threads.size).to eq(0)
-    end
-  end
-
-  context 'default one thread per job behaviour' do
-
-    it 'runs the job in a dedicated thread' do
-
-      job =
-        @scheduler.in('0s', :job => true) do
-          sleep(1)
-        end
-
-      sleep 0.4
-
-      expect(job.threads.first).not_to eq(@scheduler.thread)
-
-      sleep 1.4
-
-      expect(job.threads.size).to eq(0)
-    end
-  end
-
-  context ':allow_overlapping / :allow_overlap / :overlap' do
-
-    context 'default (:overlap => true)' do
-
-      it 'lets a job overlap itself' do
-
-        job =
-          @scheduler.every('0.3', :job => true) do
-            sleep(5)
-          end
-
-        sleep 3
-
-        expect(job.threads.size).to be > 1
-      end
-    end
-
-    context 'when :overlap => false' do
-
-      it 'prevents a job from overlapping itself' do
-
-        job =
-          @scheduler.every('0.3', :job => true, :overlap => false) do
-            sleep(5)
-          end
-
-        sleep 3
-
-        expect(job.threads.size).to eq(1)
-      end
-    end
-  end
-
-  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?
-          expect(j0.threads.size).to eq(1)
-          expect(j1.threads.size).to eq(0)
-        else
-          expect(j0.threads.size).to eq(0)
-          expect(j1.threads.size).to eq(1)
-        end
-
-        expect(@scheduler.mutexes.keys).to eq(%w[ vladivostok ])
-      end
-    end
-
-    context ':mutex => mutex_instance' do
-
-      it 'prevents concurrent executions' do
-
-        m = Mutex.new
-
-        j0 = @scheduler.in('0s', :job => true, :mutex => m) { sleep(3) }
-        j1 = @scheduler.in('0s', :job => true, :mutex => m) { sleep(3) }
-
-        sleep 0.7
-
-        if j0.threads.any?
-          expect(j0.threads.size).to eq(1)
-          expect(j1.threads.size).to eq(0)
-        else
-          expect(j0.threads.size).to eq(0)
-          expect(j1.threads.size).to eq(1)
-        end
-
-        expect(@scheduler.mutexes.keys).to eq([])
-      end
-    end
-
-    context ':mutex => [ array_of_mutex_names_or_instances ]' do
-
-      it 'prevents concurrent executions' 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
-
-        sleep 0.7
-
-        if j0.threads.any?
-          expect(j0.threads.size).to eq(1)
-          expect(j1.threads.size).to eq(0)
-        else
-          expect(j0.threads.size).to eq(0)
-          expect(j1.threads.size).to eq(1)
-        end
-
-        expect(@scheduler.mutexes.keys.sort).to eq(%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)
-
-      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
-
-      counter = 0
-
-      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
-
-      sleep(3)
-
-      expect(counter).to eq(1)
-    end
-
-    it 'starts timing when the job enters successfully all its mutexes' do
-
-      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
-
-      expect(t0).to be <= t1
-
-      d = t2 - t1
-      expect(d).to be >= 1.0
-      expect(d).to be < 1.5
-    end
-
-    it 'emits the timeout information to $stderr (default #on_error)' do
-
-      @scheduler.every('1s', :timeout => '0.5s') do
-        sleep 0.9
-      end
-
-      sleep 2
-
-      expect($stderr.string).to match(/Rufus::Scheduler::TimeoutError/)
-    end
-
-    it 'does not prevent a repeat job from recurring' do
-
-      counter = 0
-
-      @scheduler.every('1s', :timeout => '0.5s') do
-        counter = counter + 1
-        sleep 0.9
-      end
-
-      sleep 3
-
-      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
-
-  context 'one time job' do
-
-    describe '#determine_id' do
-
-      it 'returns unique ids' do
-
-        ids = []
-
-        10_000.times { ids << @scheduler.in('1y') {} }
-
-        expect(ids.uniq.length).to eq(ids.length)
-      end
-    end
-  end
-
-  context 'repeat job' do
-
-    describe '#determine_id' do
-
-      it 'returns unique ids' do
-
-        ids = []
-
-        10_000.times { ids << @scheduler.every('1y') {} }
-
-        expect(ids.uniq.length).to eq(ids.length)
-      end
-    end
-  end
-end
-