rufus-scheduler 3.1.9 → 3.1.10

data/spec/schedule_at_spec.rb

@@ -1,158 +0,0 @@
-
-#
-# Specifying rufus-scheduler
-#
-# Wed Apr 17 06:00:59 JST 2013
-#
-
-require 'spec_helper'
-
-
-describe Rufus::Scheduler do
-
-  before :each do
-    @scheduler = Rufus::Scheduler.new
-  end
-  after :each do
-    @scheduler.shutdown
-  end
-
-  describe '#at' do
-
-    it 'raises if the block to schedule is missing' do
-
-      expect {
-        @scheduler.at(Time.now + 3600)
-      }.to raise_error(ArgumentError)
-    end
-
-    it 'returns a job id' do
-
-      job_id =
-        @scheduler.at(Time.now + 3600) do
-        end
-
-      expect(job_id.class).to eq(String)
-      expect(job_id).to match(/^at_/)
-    end
-
-    it 'returns a job if :job => true' do
-
-      job =
-        @scheduler.at(Time.now + 3600, :job => true) do
-        end
-
-      expect(job.class).to eq(Rufus::Scheduler::AtJob)
-    end
-
-    it 'adds a job' do
-
-      t = Time.now + 3600
-
-      @scheduler.at(t) do
-      end
-
-      expect(@scheduler.jobs.size).to eq(1)
-      expect(@scheduler.jobs.first.class).to eq(Rufus::Scheduler::AtJob)
-      expect(@scheduler.jobs.first.time).to eq(t)
-    end
-
-    it 'triggers a job' do
-
-      a = false
-
-      @scheduler.at(Time.now + 0.100) do
-        a = true
-      end
-
-      sleep 0.4
-
-      expect(a).to eq(true)
-    end
-
-    it 'removes the job after execution' do
-
-      @scheduler.at(Time.now + 0.100) do
-      end
-
-      sleep 0.4
-
-      expect(@scheduler.jobs.size).to eq(0)
-    end
-
-    it 'accepts a Time instance' do
-
-      t = Time.now + 3600
-
-      job = @scheduler.at(t, :job => true) {}
-
-      expect(job.time).to eq(t)
-    end
-
-    it 'accepts a time string' do
-
-      job = @scheduler.at('2100-12-12 20:30', :job => true) {}
-
-      expect(job.time).to eq(Time.parse('2100-12-12 20:30'))
-    end
-
-    it 'accepts a time string with a delta timezone' do
-
-      job = @scheduler.at('2100-12-12 20:30 -0200', :job => true) {}
-
-      expect(job.time).to eq(Time.parse('2100-12-12 20:30 -0200'))
-    end
-
-    it 'accepts a time string with a named timezone' do
-
-      job = @scheduler.at('2050-12-12 20:30 Europe/Berlin', :job => true) {}
-
-      expect(job.time.strftime('%c %z')).to eq('Mon Dec 12 20:30:00 2050 +0100')
-    end
-
-    it 'accepts a Chronic string (if Chronic is present)' do
-
-      with_chronic do
-
-        job = @scheduler.schedule_at('next tuesday at 12:00') {}
-
-        expect(job.time.wday).to eq(2)
-        expect(job.time.hour).to eq(12)
-        expect(job.time.min).to eq(0)
-        expect(job.time).to be > Time.now
-      end
-    end
-
-    it 'accepts a Chronic string and Chronic options (if Chronic present)' do
-
-      with_chronic do
-
-        job =
-          @scheduler.schedule_at(
-            'may 27th at 12:00', :now => Time.local(Time.now.year + 2, 1, 1)
-          ) {}
-
-        expect(job.time.year).to eq(Time.now.year + 2)
-        expect(job.time.month).to eq(5)
-        expect(job.time.day).to eq(27)
-        expect(job.time.hour).to eq(12)
-        expect(job.time.min).to eq(0)
-      end
-    end
-
-    it 'accepts an ActiveSupport time thinggy'
-  end
-
-  describe '#schedule_at' do
-
-    it 'returns a job' do
-
-      job = @scheduler.schedule_at(Time.now + 3600) do
-      end
-
-      expect(job.class).to eq(Rufus::Scheduler::AtJob)
-      expect(job.id).to match(/^at_/)
-    end
-  end
-end
-

data/spec/schedule_cron_spec.rb

@@ -1,66 +0,0 @@
-
-#
-# Specifying rufus-scheduler
-#
-# Sat Jul 13 04:52:08 JST 2013
-#
-# In the train between Bern and Fribourg, riding back
-# from the @ruvetia drinkup
-#
-
-require 'spec_helper'
-
-
-describe Rufus::Scheduler do
-
-  before :each do
-    @scheduler = Rufus::Scheduler.new
-  end
-  after :each do
-    @scheduler.shutdown
-  end
-
-  describe '#cron' do
-
-    it 'schedules' do
-
-      counter = 0
-
-      sleep_until_next_second
-      sleep 0.3 # make sure to schedule right after a scheduler 'tick'
-
-      job =
-        @scheduler.cron '* * * * * *', :job => true do
-          counter = counter + 1
-        end
-
-      sleep_until_next_second
-      sleep_until_next_second
-      sleep 0.3 # be sure to be well into the second
-
-      expect(counter).to eq(2)
-    end
-
-    it 'raises if the job frequency is higher than the scheduler frequency' do
-
-      @scheduler.frequency = 10
-
-      expect {
-        @scheduler.cron '* * * * * *' do; end
-      }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe '#schedule_cron' do
-
-    it 'returns a CronJob instance' do
-
-      job = @scheduler.schedule_cron '* * * * *' do; end
-
-      expect(job.class).to eq(Rufus::Scheduler::CronJob)
-      expect(job.original).to eq('* * * * *')
-      expect(job.job_id).to match(/^cron_/)
-    end
-  end
-end
-

data/spec/schedule_every_spec.rb

@@ -1,109 +0,0 @@
-
-#
-# Specifying rufus-scheduler
-#
-# Wed Apr 17 06:00:59 JST 2013
-#
-
-require 'spec_helper'
-
-
-describe Rufus::Scheduler do
-
-  before :each do
-    @scheduler = Rufus::Scheduler.new
-  end
-  after :each do
-    @scheduler.shutdown
-  end
-
-  describe '#every' do
-
-    it 'adds a job' do
-
-      @scheduler.every(10) do
-      end
-
-      expect(@scheduler.jobs.size).to eq(1)
-      expect(@scheduler.jobs.first.class).to eq(Rufus::Scheduler::EveryJob)
-    end
-
-    it 'triggers a job (2 times)' do
-
-      counter = 0
-
-      @scheduler.every(0.4) do
-        counter += 1
-      end
-
-      sleep 2.0
-
-      expect(counter).to be > 2
-    end
-
-    it 'does not remove the job after execution' do
-
-      @scheduler.every(0.4) do
-      end
-
-      sleep 0.9
-
-      expect(@scheduler.jobs.size).to eq(1)
-    end
-
-    it 'raises on negative frequencies' do
-
-      expect {
-        @scheduler.every(-1) do
-        end
-      }.to raise_error(ArgumentError)
-    end
-
-    it 'raises on zero frequencies' do
-
-      expect {
-        @scheduler.every(0) do
-        end
-      }.to raise_error(ArgumentError)
-    end
-
-    it 'does not reschedule if the job was unscheduled' do
-
-      counter = 0
-
-      job =
-        @scheduler.schedule_every '0.5s' do
-          counter = counter + 1
-        end
-
-      sleep 1.6
-
-      job.unschedule
-      c = counter
-
-      sleep 1.6
-
-      expect(counter).to eq(c)
-    end
-
-    it 'raises if the job frequency is higher than the scheduler frequency' do
-
-      @scheduler.frequency = 10
-
-      expect {
-        @scheduler.every '1s' do; end
-      }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe '#schedule_every' do
-
-    it 'accepts a duration string' do
-
-      job = @scheduler.schedule_every('1h') do; end
-
-      expect(job.frequency).to eq(3600.0)
-    end
-  end
-end
-

data/spec/schedule_in_spec.rb

@@ -1,80 +0,0 @@
-
-#
-# Specifying rufus-scheduler
-#
-# Wed Apr 17 06:00:59 JST 2013
-#
-
-require 'spec_helper'
-
-
-describe Rufus::Scheduler do
-
-  before :each do
-    @scheduler = Rufus::Scheduler.new
-  end
-  after :each do
-    @scheduler.shutdown
-  end
-
-  describe '#in' do
-
-    it 'adds a job' do
-
-      @scheduler.in(3600) do
-      end
-
-      expect(@scheduler.jobs.size).to eq(1)
-      expect(@scheduler.jobs.first.class).to eq(Rufus::Scheduler::InJob)
-    end
-
-    it 'triggers a job' do
-
-      a = false
-
-      @scheduler.in(0.4) do
-        a = true
-      end
-
-      sleep 0.9
-
-      expect(a).to eq(true)
-    end
-
-    it 'removes the job after execution' do
-
-      @scheduler.in(0.4) do
-      end
-
-      sleep 0.700
-
-      expect(@scheduler.jobs.size).to eq(0)
-    end
-  end
-
-  describe '#schedule_in' do
-
-    it 'accepts a number' do
-
-      job = @scheduler.schedule_in(3600) {}
-
-      expect(job.original).to eq(3600)
-    end
-
-    it 'accepts a duration string' do
-
-      job = @scheduler.schedule_in('1h') {}
-
-      expect(job.original).to eq('1h')
-      expect(job.time).to be >= job.scheduled_at + 3509
-      expect(job.time).to be <= job.scheduled_at + 3601
-    end
-
-    it 'accepts an ActiveSupport .from_now thinggy'
-      #
-      #   schedule_in(2.days.from_now)
-      #
-      # that'd simply require "in" to be a bit like "at"...
-  end
-end
-

data/spec/schedule_interval_spec.rb

@@ -1,128 +0,0 @@
-
-#
-# Specifying rufus-scheduler
-#
-# Wed Aug  7 06:20:55 JST 2013
-#
-
-require 'spec_helper'
-
-
-describe Rufus::Scheduler do
-
-  before :each do
-    @scheduler = Rufus::Scheduler.new
-  end
-  after :each do
-    @scheduler.shutdown
-  end
-
-  describe '#interval' do
-
-    it 'adds a job' do
-
-      @scheduler.interval(10) do
-      end
-
-      expect(@scheduler.jobs.size).to eq(1)
-      expect(@scheduler.jobs.first.class).to eq(Rufus::Scheduler::IntervalJob)
-    end
-
-    it 'triggers a job (2 times)' do
-
-      counter = 0
-
-      @scheduler.interval(0.4) do
-        counter += 1
-      end
-
-      sleep 2.0
-
-      expect(counter).to be > 2
-    end
-
-    it 'triggers, but reschedules after the trigger execution' do
-
-      chronos = []
-
-      @scheduler.interval(0.4) do
-        now = Time.now
-        last, delta = chronos.last
-        chronos << [ now, last ? now - last : nil ]
-        sleep 0.5
-      end
-
-      t = Time.now
-      sleep 0.1 while chronos.size < 4 && Time.now < t + 5
-
-      expect(chronos.size).to eq(4)
-
-      deltas = chronos.collect(&:last).compact
-
-      #pp chronos
-      #pp deltas
-
-      deltas.each do |d|
-        expect(d).to be >= 0.9
-      end
-    end
-
-    it 'does not reschedule if the job was unscheduled' do
-
-      counter = 0
-
-      job =
-        @scheduler.schedule_interval '0.5s' do
-          counter = counter + 1
-        end
-
-      sleep 1.6
-
-      expect(@scheduler.jobs(:all).size).to eq(1)
-
-      job.unschedule
-      c = counter
-
-      sleep 1.6
-
-      expect(counter).to eq(c)
-      expect(@scheduler.jobs(:all).size).to eq(0)
-    end
-
-    it 'raises on negative intervals' do
-
-      expect {
-        @scheduler.interval(-1) do
-        end
-      }.to raise_error(ArgumentError)
-    end
-
-    it 'raises on zero intervals' do
-
-      expect {
-        @scheduler.interval(0) do
-        end
-      }.to raise_error(ArgumentError)
-    end
-
-    #it 'raises if the job frequency is higher than the scheduler frequency' do
-    #
-    #  @scheduler.frequency = 10
-    #
-    #  lambda {
-    #    @scheduler.interval '1s' do; end
-    #  }.should raise_error(ArgumentError)
-    #end
-  end
-
-  describe '#schedule_interval' do
-
-    it 'accepts a duration string' do
-
-      job = @scheduler.schedule_interval('1h') do; end
-
-      expect(job.interval).to eq(3600)
-    end
-  end
-end
-