rufus-scheduler 3.1.4 → 3.8.2

data/spec/lock_lockfile_spec.rb

@@ -1,61 +0,0 @@
-
-#
-# Specifying rufus-scheduler
-#
-# Tue Aug 13 05:58:48 JST 2013
-#
-
-require 'spec_helper'
-
-
-describe Rufus::Scheduler do
-
-  after :each do
-
-    FileUtils.rm_f('.rufus-scheduler.lock')
-    FileUtils.rm_f('lock.txt')
-  end
-
-  context ':lockfile => ".rufus-scheduler.lock"' do
-
-    it 'writes down a .rufus-scheduler.lock file' do
-
-      s = Rufus::Scheduler.new :lockfile => '.rufus-scheduler.lock'
-
-      line = File.read('.rufus-scheduler.lock')
-
-      #p line
-      expect(line).to match(/pid: #{$$}/)
-    end
-
-    it '"flocks" the lock file' do
-
-      s = Rufus::Scheduler.new :lockfile => '.rufus-scheduler.lock'
-
-      f = File.new('.rufus-scheduler.lock', 'a')
-
-      expect(f.flock(File::LOCK_NB | File::LOCK_EX)).to eq(false)
-    end
-
-    it 'prevents newer schedulers from starting' do
-
-      s0 = Rufus::Scheduler.new :lockfile => '.rufus-scheduler.lock'
-      s1 = Rufus::Scheduler.new :lockfile => '.rufus-scheduler.lock'
-
-      expect(s0.started_at).not_to eq(nil)
-      expect(s1.started_at).to eq(nil)
-    end
-
-    it 'releases the lockfile when shutting down' do
-
-      s = Rufus::Scheduler.new :lockfile => '.rufus-scheduler.lock'
-
-      s.shutdown(:kill)
-
-      f = File.new('.rufus-scheduler.lock', 'a')
-
-      expect(f.flock(File::LOCK_NB | File::LOCK_EX)).to eq(0)
-    end
-  end
-end
-

data/spec/lock_spec.rb

@@ -1,59 +0,0 @@
-
-#
-# Specifying rufus-scheduler
-#
-# Sat Aug 16 05:42:11 JST 2014
-# added by @ecin
-#
-
-require 'spec_helper'
-
-
-describe Rufus::Scheduler do
-
-  context "when running multiple schedulers side-by-side" do
-
-    class AlwaysLock
-      def lock; true; end
-      def unlock; true; end
-      def locked?; true; end
-    end
-
-    class NeverLock
-      def lock; false; end
-      def unlock; true; end
-      def locked?; true; end
-    end
-
-    it "only starts if it can acquire a scheduler lock" do
-
-      main = Rufus::Scheduler.new :scheduler_lock => AlwaysLock.new
-      backup = Rufus::Scheduler.new :scheduler_lock => NeverLock.new
-
-      expect(main).to be_up
-      expect(backup).to be_down
-    end
-
-    it "only triggers jobs when it can acquire a trigger lock" do
-
-      main = Rufus::Scheduler.new(:trigger_lock => AlwaysLock.new)
-      backup = Rufus::Scheduler.new(:trigger_lock => NeverLock.new)
-
-      expect(main).to be_up
-      expect(backup).to be_up
-
-      counter = 0
-      job = proc { counter += 1 }
-      main.schedule_in(0, job)
-      backup.schedule_in(0, job)
-
-      sleep 0.5
-
-      expect(main.jobs).to be_empty
-      expect(backup.jobs.count).to eq(1)
-      expect(backup.jobs.first.next_time).to be(false)
-      expect(counter).to eq(1)
-    end
-  end
-end
-

data/spec/parse_spec.rb

@@ -1,263 +0,0 @@
-
-#
-# Specifying rufus-scheduler
-#
-# Wed Apr 17 06:00:59 JST 2013
-#
-
-require 'spec_helper'
-
-
-describe Rufus::Scheduler do
-
-  describe '.parse' do
-
-    def pa(s, opts={}); Rufus::Scheduler.parse(s, opts); end
-
-    it 'parses duration strings' do
-
-      expect(pa('1.0d1.0w1.0d')).to eq(777600.0)
-    end
-
-    it 'parses datetimes' do
-
-      # local
-
-      expect(pa('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
-
-      expect(
-        pa('Sun Nov 18 16:01:00 2012 Asia/Singapore').getutc.strftime('%c %z')
-      ).to eq('Sun Nov 18 08:01:00 2012 +0000')
-
-      expect(pa('Sun Nov 18 16:01:00 2012 Zulu').getutc.strftime('%c')).to eq(
-        'Sun Nov 18 16:01:00 2012'
-      )
-
-      expect(
-        pa('Sun Nov 18 16:01:00 Asia/Singapore 2012').getutc.strftime('%c %z')
-      ).to eq('Sun Nov 18 08:01:00 2012 +0000')
-
-      expect(
-        pa('Asia/Singapore Sun Nov 18 16:01:00 2012').getutc.strftime('%c %z')
-      ).to eq('Sun Nov 18 08:01:00 2012 +0000')
-
-      expect(
-        pa('Sun Nov 18 16:01:00 2012 America/New_York').getutc.strftime('%c %z')
-      ).to eq('Sun Nov 18 21:01:00 2012 +0000')
-    end
-
-    it 'parses datetimes with named timezones' do
-
-      expect(pa(
-        'Sun Nov 18 16:01:00 2012 Europe/Berlin'
-      ).strftime('%c %z')).to eq(
-        'Sun Nov 18 16:01:00 2012 +0100'
-      )
-    end
-
-    it 'parses datetimes (with the local timezone implicitely)' do
-
-      localzone = Time.now.strftime('%z')
-
-      expect(
-        pa('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 = pa('* * * * *')
-
-      expect(out.class).to eq(Rufus::Scheduler::CronLine)
-      expect(out.original).to eq('* * * * *')
-
-      expect(pa('10 23 * * *').class).to eq(Rufus::Scheduler::CronLine)
-      expect(pa('* 23 * * *').class).to eq(Rufus::Scheduler::CronLine)
-    end
-
-    it 'raises on unparseable input' do
-
-      expect {
-        pa('nada')
-      }.to raise_error(ArgumentError, 'couldn\'t parse "nada"')
-    end
-
-    it 'does not use Chronic if not present' do
-
-      t = pa('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 = pa('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 = pa('monday', :context => :past)
-
-        expect(t.wday).to eq(1)
-        expect(t).to be < Time.now
-      end
-    end
-  end
-
-  describe '.parse_duration' do
-
-    def pd(s)
-      Rufus::Scheduler.parse_duration(s)
-    end
-
-    it 'parses duration strings' do
-
-      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
-
-      expect(pd(0.1)).to eq(0.1)
-    end
-
-    it 'raises on wrong duration strings' do
-
-      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)
-
-      expect { pd(' 1h ') }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe '.parse_time_string -> .parse_duration' do
-
-    it 'is still around for libs using it out there' do
-
-      expect(Rufus::Scheduler.parse_time_string('1d1w1d')).to eq(777600.0)
-    end
-  end
-
-  describe '.parse_duration_string -> .parse_duration' do
-
-    it 'is still around for libs using it out there' do
-
-      expect(Rufus::Scheduler.parse_duration_string('1d1w1d')).to eq(777600.0)
-    end
-  end
-
-  describe '.to_duration' do
-
-    def td(o, opts={})
-      Rufus::Scheduler.to_duration(o, opts)
-    end
-
-    it 'turns integers into duration strings' do
-
-      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
-
-      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
-
-      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
-
-      expect(td(0.1)).to eq('100')
-      expect(td(1.1)).to eq('1s100')
-    end
-  end
-
-  describe '.to_duration_hash' do
-
-    def tdh(o, opts={})
-      Rufus::Scheduler.to_duration_hash(o, opts)
-    end
-
-    it 'turns integers duration hashes' do
-
-      expect(tdh(0)).to eq({})
-      expect(tdh(60)).to eq({ :m => 1 })
-    end
-
-    it 'turns floats duration hashes' do
-
-      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
-
-      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
-

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
-