rufus-scheduler 3.1.9 → 3.1.10

data/spec/lock_custom_spec.rb

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

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

@@ -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
-