rufus-scheduler 2.0.24 → 3.1.0

data/spec/lock_custom_spec.rb

@@ -0,0 +1,47 @@
+
+#
+# Specifying rufus-scheduler
+#
+# Fri Nov  1 05:56:03 JST 2013
+#
+# Ishinomaki
+#
+
+require 'spec_helper'
+
+
+describe Rufus::Scheduler do
+
+  class LosingLockScheduler < Rufus::Scheduler
+
+    attr_reader :counter
+
+    def initialize
+      super
+      @counter = 0
+    end
+
+    def confirm_lock
+      @counter = @counter + 1
+      false
+    end
+  end
+
+  context 'custom locks' do
+
+    it 'does not trigger when #confirm_lock returns false' do
+
+      s = LosingLockScheduler.new
+
+      count = 0
+
+      s.in('0s') { count = count + 1 }
+
+      sleep 0.7
+
+      expect(count).to eq(0)
+      expect(s.counter).to eq(1)
+    end
+  end
+end
+

data/spec/lock_flock_spec.rb

@@ -0,0 +1,47 @@
+
+#
+# Specifying rufus-scheduler
+#
+# Sat Aug 16 05:43:06 JST 2014
+# added by @ecin
+#
+
+require 'spec_helper'
+
+
+describe Rufus::Scheduler::FileLock do
+
+  before :each do
+
+    @lock_path = '.rufus-scheduler.lock'
+    @lock = Rufus::Scheduler::FileLock.new(@lock_path)
+  end
+
+  after :each do
+
+    FileUtils.rm_f(@lock_path)
+    FileUtils.rm_f('lock.txt')
+  end
+
+  context ':scheduler_lock => Rufus::Scheduler::FileLock.new(path)' do
+
+    it 'writes down a .rufus-scheduler.lock file' do
+
+      @lock.lock
+
+      line = File.read(@lock_path)
+
+      expect(line).to match(/pid: #{$$}/)
+    end
+
+    it '"flocks" the lock file' do
+
+      @lock.lock
+
+      f = File.new(@lock_path, 'a')
+
+      expect(f.flock(File::LOCK_NB | File::LOCK_EX)).to eq(false)
+    end
+  end
+end
+

data/spec/lock_lockfile_spec.rb

@@ -0,0 +1,61 @@
+
+#
+# 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

@@ -0,0 +1,59 @@
+
+#
+# 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

@@ -0,0 +1,263 @@
+
+#
+# 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

@@ -0,0 +1,158 @@
+
+#
+# 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

@@ -0,0 +1,66 @@
+
+#
+# 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
+