rufus-scheduler 2.0.24 → 3.0.0

data/spec/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
+      line.should match(/pid: #{$$}/)
+    end
+
+    it '"flocks" the lock file' do
+
+      s = Rufus::Scheduler.new :lockfile => '.rufus-scheduler.lock'
+
+      f = File.new('.rufus-scheduler.lock', 'a')
+
+      f.flock(File::LOCK_NB | File::LOCK_EX).should == 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'
+
+      s0.started_at.should_not == nil
+      s1.started_at.should == 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')
+
+      f.flock(File::LOCK_NB | File::LOCK_EX).should == 0
+    end
+  end
+end
+

data/spec/parse_spec.rb

@@ -0,0 +1,203 @@
+
+#
+# Specifying rufus-scheduler
+#
+# Wed Apr 17 06:00:59 JST 2013
+#
+
+require 'spec_helper'
+
+
+describe Rufus::Scheduler do
+
+  describe '.parse' do
+
+    def parse(s)
+      Rufus::Scheduler.parse(s)
+    end
+
+    it 'parses duration strings' do
+
+      parse('1.0d1.0w1.0d').should == 777600.0
+    end
+
+    it 'parses datetimes' do
+
+      # local
+
+      parse('Sun Nov 18 16:01:00 2012').strftime('%c').should ==
+        'Sun Nov 18 16:01:00 2012'
+    end
+
+    it 'parses datetimes with timezones' do
+
+      parse('Sun Nov 18 16:01:00 2012 Japan').getutc.strftime('%c').should ==
+        'Sun Nov 18 07:01:00 2012'
+
+      parse('Sun Nov 18 16:01:00 2012 Zulu').getutc.strftime('%c').should ==
+        'Sun Nov 18 16:01:00 2012'
+
+      parse('Sun Nov 18 16:01:00 Japan 2012').getutc.strftime('%c').should ==
+        'Sun Nov 18 07:01:00 2012'
+
+      parse('Japan Sun Nov 18 16:01:00 2012').getutc.strftime('%c').should ==
+        'Sun Nov 18 07:01:00 2012'
+    end
+
+    it 'parses datetimes with named timezones' do
+
+      parse(
+        'Sun Nov 18 16:01:00 2012 Europe/Berlin'
+      ).strftime('%c %z').should ==
+        'Sun Nov 18 15:01:00 2012 +0000'
+    end
+
+    it 'parses datetimes (with the local timezone implicitely)' do
+
+      localzone = Time.now.strftime('%z')
+
+      parse('Sun Nov 18 16:01:00 2012').strftime('%c %z').should ==
+        "Sun Nov 18 16:01:00 2012 #{localzone}"
+    end
+
+    it 'parses cronlines' do
+
+      out = parse('* * * * *')
+
+      out.class.should == Rufus::Scheduler::CronLine
+      out.original.should == '* * * * *'
+
+      parse('10 23 * * *').class.should == Rufus::Scheduler::CronLine
+      parse('* 23 * * *').class.should == Rufus::Scheduler::CronLine
+    end
+
+    it 'raises on unparseable input' do
+
+      lambda {
+        parse('nada')
+      }.should raise_error(ArgumentError, 'couldn\'t parse "nada"')
+    end
+  end
+
+  describe '.parse_duration' do
+
+    def pd(s)
+      Rufus::Scheduler.parse_duration(s)
+    end
+
+    it 'parses duration strings' do
+
+      pd('-1.0d1.0w1.0d').should == -777600.0
+      pd('-1d1w1d').should == -777600.0
+      pd('-1w2d').should == -777600.0
+      pd('-1h10s').should == -3610.0
+      pd('-1h').should == -3600.0
+      pd('-5.').should == -5.0
+      pd('-2.5s').should == -2.5
+      pd('-1s').should == -1.0
+      pd('-500').should == -500
+      pd('').should == 0.0
+      pd('5.0').should == 5.0
+      pd('0.5').should == 0.5
+      pd('.5').should == 0.5
+      pd('5.').should == 5.0
+      pd('500').should == 500
+      pd('1000').should == 1000
+      pd('1').should == 1.0
+      pd('1s').should == 1.0
+      pd('2.5s').should == 2.5
+      pd('1h').should == 3600.0
+      pd('1h10s').should == 3610.0
+      pd('1w2d').should == 777600.0
+      pd('1d1w1d').should == 777600.0
+      pd('1.0d1.0w1.0d').should == 777600.0
+
+      pd('.5m').should == 30.0
+      pd('5.m').should == 300.0
+      pd('1m.5s').should == 60.5
+      pd('-.5m').should == -30.0
+
+      pd('1').should == 1
+      pd('0.1').should == 0.1
+      pd('1s').should == 1
+    end
+
+    it 'calls #to_s on its input' do
+
+      pd(0.1).should == 0.1
+    end
+
+    it 'raises on wrong duration strings' do
+
+      lambda { pd('-') }.should raise_error(ArgumentError)
+      lambda { pd('h') }.should raise_error(ArgumentError)
+      lambda { pd('whatever') }.should raise_error(ArgumentError)
+      lambda { pd('hms') }.should raise_error(ArgumentError)
+
+      lambda { pd(' 1h ') }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe '.to_duration' do
+
+    def td(o, opts={})
+      Rufus::Scheduler.to_duration(o, opts)
+    end
+
+    it 'turns integers into duration strings' do
+
+      td(0).should == '0s'
+      td(60).should == '1m'
+      td(61).should == '1m1s'
+      td(3661).should == '1h1m1s'
+      td(24 * 3600).should == '1d'
+      td(7 * 24 * 3600 + 1).should == '1w1s'
+      td(30 * 24 * 3600 + 1).should == '4w2d1s'
+    end
+
+    it 'ignores seconds and milliseconds if :drop_seconds => true' do
+
+      td(0, :drop_seconds => true).should == '0m'
+      td(5, :drop_seconds => true).should == '0m'
+      td(61, :drop_seconds => true).should == '1m'
+    end
+
+    it 'displays months if :months => true' do
+
+      td(1, :months => true).should == '1s'
+      td(30 * 24 * 3600 + 1, :months => true).should == '1M1s'
+    end
+
+    it 'turns floats into duration strings' do
+
+      td(0.1).should == '100'
+      td(1.1).should == '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
+
+      tdh(0).should == {}
+      tdh(60).should == { :m => 1 }
+    end
+
+    it 'turns floats duration hashes' do
+
+      tdh(0.128).should == { :ms => 128 }
+      tdh(60.127).should == { :m => 1, :ms => 127 }
+    end
+
+    it 'drops seconds and milliseconds if :drop_seconds => true' do
+
+      tdh(61.127).should == { :m => 1, :s => 1, :ms => 127 }
+      tdh(61.127, :drop_seconds => true).should == { :m => 1 }
+    end
+  end
+end
+

data/spec/schedule_at_spec.rb

@@ -0,0 +1,129 @@
+
+#
+# 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
+
+      lambda {
+        @scheduler.at(Time.now + 3600)
+      }.should raise_error(ArgumentError)
+    end
+
+    it 'returns a job id' do
+
+      job_id =
+        @scheduler.at(Time.now + 3600) do
+        end
+
+      job_id.class.should == String
+      job_id.should match(/^at_/)
+    end
+
+    it 'returns a job if :job => true' do
+
+      job =
+        @scheduler.at(Time.now + 3600, :job => true) do
+        end
+
+      job.class.should == Rufus::Scheduler::AtJob
+    end
+
+    it 'adds a job' do
+
+      t = Time.now + 3600
+
+      @scheduler.at(t) do
+      end
+
+      @scheduler.jobs.size.should == 1
+      @scheduler.jobs.first.class.should == Rufus::Scheduler::AtJob
+      @scheduler.jobs.first.time.should == t
+    end
+
+    it 'triggers a job' do
+
+      a = false
+
+      @scheduler.at(Time.now + 0.100) do
+        a = true
+      end
+
+      sleep 0.4
+
+      a.should == true
+    end
+
+    it 'removes the job after execution' do
+
+      @scheduler.at(Time.now + 0.100) do
+      end
+
+      sleep 0.4
+
+      @scheduler.jobs.size.should == 0
+    end
+
+    it 'accepts a Time instance' do
+
+      t = Time.now + 3600
+
+      job = @scheduler.at(t, :job => true) {}
+
+      job.time.should == t
+    end
+
+    it 'accepts a time string' do
+
+      job = @scheduler.at('2100-12-12 20:30', :job => true) {}
+
+      job.time.should == 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) {}
+
+      job.time.should == 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) {}
+
+      job.time.strftime('%c %z').should == 'Mon Dec 12 19:30:00 2050 +0000'
+    end
+
+    it 'accepts a Chronic time string (if Chronic is present)'
+    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
+
+      job.class.should == Rufus::Scheduler::AtJob
+      job.id.should 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
+
+      counter.should == 2
+    end
+
+    it 'raises if the job frequency is higher than the scheduler frequency' do
+
+      @scheduler.frequency = 10
+
+      lambda {
+        @scheduler.cron '* * * * * *' do; end
+      }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe '#schedule_cron' do
+
+    it 'returns a CronJob instance' do
+
+      job = @scheduler.schedule_cron '* * * * *' do; end
+
+      job.class.should == Rufus::Scheduler::CronJob
+      job.original.should == '* * * * *'
+      job.job_id.should match(/^cron_/)
+    end
+  end
+end
+