tickwork 0.0.1

data/test/manager_test.rb

@@ -0,0 +1,576 @@
+require File.expand_path('../../lib/tickwork', __FILE__)
+require File.expand_path('../data_stores/fake_store.rb', __FILE__)
+require File.expand_path('../null_logger.rb', __FILE__)
+require "minitest/autorun"
+require 'mocha/mini_test'
+require 'time'
+require 'active_support/time'
+
+describe Tickwork::Manager do
+def self.test_order
+   :alpha
+end
+  before do
+    @manager = Tickwork::Manager.new
+    @manager.configure do |config|
+      config[:data_store] = Tickwork::FakeStore.new
+      config[:logger] = NullLogger.new
+    end
+    class << @manager
+      def log(msg); end
+    end
+    @manager.handler { }
+  end
+
+  def assert_will_run(t)
+    if t.is_a? String
+      t = Time.parse(t)
+    end
+    assert_equal 1, @manager.tick(t).size
+  end
+
+  def assert_wont_run(t)
+    if t.is_a? String
+      t = Time.parse(t)
+    end
+    assert_equal 0, @manager.tick(t).size
+  end
+
+  it "once a minute" do
+    @manager.every(1.minute, 'myjob')
+
+    assert_will_run(t=Time.now)
+    assert_wont_run(t+30)
+    assert_will_run(t+60)
+  end
+
+  it "every three minutes" do
+    @manager.every(3.minutes, 'myjob')
+
+    assert_will_run(t=Time.now)
+    assert_wont_run(t+2*60)
+    assert_will_run(t+3*60)
+  end
+
+  it "once an hour" do
+    @manager.every(1.hour, 'myjob')
+
+    assert_will_run(t=Time.now)
+    assert_wont_run(t+30*60)
+    assert_will_run(t+60*60)
+  end
+
+  it "once a week" do
+    @manager.every(1.week, 'myjob')
+
+    assert_will_run(t=Time.now)
+    assert_wont_run(t+60*60*24*6)
+    assert_will_run(t+60*60*24*7)
+  end
+
+  it "won't drift later and later" do
+    @manager.every(1.hour, 'myjob')
+
+    assert_will_run(Time.parse("10:00:00.5"))
+    assert_wont_run(Time.parse("10:59:59.999"))
+    assert_will_run(Time.parse("11:00:00.0"))
+  end
+
+  it "aborts when no handler defined" do
+    manager = Tickwork::Manager.new
+    assert_raises(Tickwork::Manager::NoHandlerDefined) do
+      manager.every(1.minute, 'myjob')
+    end
+  end
+
+  it "aborts when fails to parse" do
+    assert_raises(Tickwork::At::FailedToParse) do
+      @manager.every(1.day, "myjob", :at => "a:bc")
+    end
+  end
+
+  it "general handler" do
+    $set_me = 0
+    @manager.handler { $set_me = 1 }
+    @manager.every(1.minute, 'myjob')
+    @manager.tick(Time.now)
+    assert_equal 1, $set_me
+  end
+
+  it "event-specific handler" do
+    $set_me = 0
+    @manager.every(1.minute, 'myjob') { $set_me = 2 }
+    @manager.tick(Time.now)
+
+    assert_equal 2, $set_me
+  end
+
+  it "should pass time to the general handler" do
+    received = nil
+    now = Time.now
+    @manager.handler { |job, time| received = time }
+    @manager.every(1.minute, 'myjob')
+    @manager.tick(now)
+    assert_equal now, received
+  end
+
+  it "should pass time to the event-specific handler" do
+    received = nil
+    now = Time.now
+    @manager.every(1.minute, 'myjob') { |job, time| received = time }
+    @manager.tick(now)
+    assert_equal now, received
+  end
+
+  it "exceptions are trapped and logged" do
+    @manager.handler { raise 'boom' }
+    @manager.every(1.minute, 'myjob')
+
+    mocked_logger = MiniTest::Mock.new
+    mocked_logger.expect :error, true, [RuntimeError]
+    @manager.configure { |c| c[:logger] = mocked_logger }
+    @manager.tick(Time.now)
+    mocked_logger.verify
+  end
+
+  it "exceptions still set the last timestamp to avoid spastic error loops" do
+    @manager.handler { raise 'boom' }
+    event = @manager.every(1.minute, 'myjob')
+    @manager.stubs(:log_error)
+    @manager.tick(t = Time.now)
+    assert_equal t, event.last
+  end
+
+  it "should be configurable" do
+    logger = NullLogger.new
+    @manager.configure do |config|
+      config[:logger] = logger
+      config[:max_threads] = 20
+      config[:max_ticks] = 21
+      config[:tick_size] = 59
+      config[:max_catchup] = 3000
+      config[:thread] = true
+      config[:namespace] = 'superhero'
+    end
+
+    assert_equal logger, @manager.config[:logger]
+    assert_equal 20, @manager.config[:max_threads]
+    assert_equal 21, @manager.config[:max_ticks]
+    assert_equal 59, @manager.config[:tick_size]
+    assert_equal 3000, @manager.config[:max_catchup]
+    assert_equal true, @manager.config[:thread]
+    assert_equal 'superhero', @manager.config[:namespace]
+  end
+
+  it "configuration should have reasonable defaults" do
+    @manager = Tickwork::Manager.new
+    assert @manager.config[:logger].is_a?(Logger)
+    assert_equal 10, @manager.config[:max_threads]
+    assert_equal 10, @manager.config[:max_ticks]
+    assert_equal 60, @manager.config[:tick_size]
+    assert_equal 3600, @manager.config[:max_catchup]
+    assert_equal false, @manager.config[:thread]
+    assert_equal '_tickwork_', @manager.config[:namespace]
+  end
+
+  it "config raises exception without a datastore" do 
+    @my_manager = Tickwork::Manager.new
+    assert_raises Tickwork::Manager::NoDataStoreDefined do 
+      @my_manager.configure do |config|
+        config[:tick_size] = 10
+      end
+    end
+  end
+
+  it "run raises exception without a datastore" do 
+    @my_manager = Tickwork::Manager.new
+    assert_raises Tickwork::Manager::NoDataStoreDefined do 
+      @my_manager.run
+    end
+  end
+
+  describe ':at option' do
+    it "once a day at 16:20" do
+      @manager.every(1.day, 'myjob', :at => '16:20')
+
+      assert_wont_run 'jan 1 2010 16:19:59'
+      assert_will_run 'jan 1 2010 16:20:00'
+      assert_wont_run 'jan 1 2010 16:20:01'
+      assert_wont_run 'jan 2 2010 16:19:59'
+      assert_will_run 'jan 2 2010 16:20:00'
+    end
+
+    it "twice a day at 16:20 and 18:10" do
+      @manager.every(1.day, 'myjob', :at => ['16:20', '18:10'])
+
+      assert_wont_run 'jan 1 2010 16:19:59'
+      assert_will_run 'jan 1 2010 16:20:00'
+      assert_wont_run 'jan 1 2010 16:20:01'
+
+      assert_wont_run 'jan 1 2010 18:09:59'
+      assert_will_run 'jan 1 2010 18:10:00'
+      assert_wont_run 'jan 1 2010 18:10:01'
+    end
+  end
+
+  describe ':tz option' do
+    it "time zone is not set by default" do
+      assert @manager.config[:tz].nil?
+    end
+
+    it "should be able to specify a different timezone than local" do
+      @manager.every(1.day, 'myjob', :at => '10:00', :tz => 'UTC')
+
+      assert_wont_run 'jan 1 2010 10:00:00 EST'
+      assert_will_run 'jan 1 2010 10:00:00 UTC'
+    end
+
+    it "should be able to specify a different timezone than local for multiple times" do
+      @manager.every(1.day, 'myjob', :at => ['10:00', '8:00'], :tz => 'UTC')
+
+      assert_wont_run 'jan 1 2010 08:00:00 EST'
+      assert_will_run 'jan 1 2010 08:00:00 UTC'
+      assert_wont_run 'jan 1 2010 10:00:00 EST'
+      assert_will_run 'jan 1 2010 10:00:00 UTC'
+    end
+
+    it "should be able to configure a default timezone to use for all events" do
+      @manager.configure { |config| config[:tz] = 'UTC' }
+      @manager.every(1.day, 'myjob', :at => '10:00')
+
+      assert_wont_run 'jan 1 2010 10:00:00 EST'
+      assert_will_run 'jan 1 2010 10:00:00 UTC'
+    end
+
+    it "should be able to override a default timezone in an event" do
+      @manager.configure { |config| config[:tz] = 'UTC' }
+      @manager.every(1.day, 'myjob', :at => '10:00', :tz => 'EST')
+
+      assert_will_run 'jan 1 2010 10:00:00 EST'
+      assert_wont_run 'jan 1 2010 10:00:00 UTC'
+    end
+  end
+
+  describe ':if option' do
+    it ":if true then always run" do
+      @manager.every(1.second, 'myjob', :if => lambda { |_| true })
+
+      assert_will_run 'jan 1 2010 16:20:00'
+    end
+
+    it ":if false then never run" do
+      @manager.every(1.second, 'myjob', :if => lambda { |_| false })
+
+      assert_wont_run 'jan 1 2010 16:20:00'
+    end
+
+    it ":if the first day of month" do
+      @manager.every(1.second, 'myjob', :if => lambda { |t| t.day == 1 })
+
+      assert_will_run 'jan 1 2010 16:20:00'
+      assert_wont_run 'jan 2 2010 16:20:00'
+      assert_will_run 'feb 1 2010 16:20:00'
+    end
+
+    it ":if it is compared to a time with zone" do
+      tz = 'America/Chicago'
+      time = Time.utc(2012,5,25,10,00)
+      @manager.every(1.second, 'myjob', tz: tz, :if => lambda  { |t|
+            ((time - 1.hour)..(time + 1.hour)).cover? t
+            })
+      assert_will_run time
+    end
+
+    it ":if is not callable then raise ArgumentError" do
+      assert_raises(ArgumentError) do
+        @manager.every(1.second, 'myjob', :if => true)
+      end
+    end
+  end
+
+  describe "max_threads" do
+    it "should warn when an event tries to generate threads more than max_threads" do
+      logger = NullLogger.new
+      @manager.configure do |config|
+        config[:max_threads] = 1
+        config[:logger] = logger
+      end
+
+      @manager.every(1.minute, 'myjob1', :thread => true) { sleep 2 }
+      @manager.every(1.minute, 'myjob2', :thread => true) { sleep 2 }
+      logger.expects(:error).with("Threads exhausted; skipping myjob2")
+
+      @manager.tick(Time.now)
+    end
+
+    it "should not warn when thread is managed by others" do
+      begin
+        t = Thread.new { sleep 5 }
+        logger = Logger.new(StringIO.new)
+        @manager.configure do |config|
+          config[:max_threads] = 1
+          config[:logger] = logger
+        end
+
+        @manager.every(1.minute, 'myjob', :thread => true)
+        logger.expects(:error).never
+
+        @manager.tick(Time.now)
+      ensure
+        t.kill
+      end
+    end
+  end
+
+  describe "callbacks" do
+    it "should not accept unknown callback name" do
+      assert_raises(RuntimeError, "Unsupported callback unknown_callback") do
+        @manager.on(:unknown_callback) do
+          true
+        end
+      end
+    end
+
+    it "should run before_tick callback once on tick" do
+      counter = 0
+      @manager.on(:before_tick) do
+        counter += 1
+      end
+      @manager.tick
+      assert_equal 1, counter
+    end
+
+    it "should not run events if before_tick returns false" do
+      @manager.on(:before_tick) do
+        false
+      end
+      @manager.every(1.second, 'myjob') { raise "should not run" }
+      @manager.tick
+    end
+
+    it "should run before_run twice if two events are registered" do
+      counter = 0
+      @manager.on(:before_run) do
+        counter += 1
+      end
+      @manager.every(1.second, 'myjob')
+      @manager.every(1.second, 'myjob2')
+      @manager.tick
+      assert_equal 2, counter
+    end
+
+    it "should run even jobs only" do
+      counter = 0
+      ran = false
+      @manager.on(:before_run) do
+        counter += 1
+        counter % 2 == 0
+      end
+      @manager.every(1.second, 'myjob') { raise "should not ran" }
+      @manager.every(1.second, 'myjob2') { ran = true }
+      @manager.tick
+      assert ran
+    end
+
+    it "should run after_run callback for each event" do
+      counter = 0
+      @manager.on(:after_run) do
+        counter += 1
+      end
+      @manager.every(1.second, 'myjob')
+      @manager.every(1.second, 'myjob2')
+      @manager.tick
+      assert_equal 2, counter
+    end
+
+    it "should run after_tick callback once" do
+      counter = 0
+      @manager.on(:after_tick) do
+        counter += 1
+      end
+      @manager.tick
+      assert_equal 1, counter
+    end
+  end
+
+  it "should start from last tick" do 
+    @manager.configure do |config|
+      config[:tick_size] = 1
+      config[:max_ticks] = 1
+    end
+    last = Time.now.to_i - 1000
+    @manager.data_store.set(@manager.data_store_key, last)
+    @manager.expects(:tick).with(last + 1).then.returns
+    @manager.run
+  end
+
+  it "should tick to max_ticks" do 
+    @manager.configure do |config|
+      config[:tick_size] = 1
+      config[:max_ticks] = 3
+    end
+    last = Time.now.to_i - 1000
+    @manager.data_store.set(@manager.data_store_key, last)
+    @manager.expects(:tick).with(last + 1).then.returns
+    @manager.expects(:tick).with(last + 2).then.returns
+    @manager.expects(:tick).with(last + 3).then.returns
+    @manager.run
+  end
+
+  it "should tick by tick size" do 
+    @manager.configure do |config|
+      config[:tick_size] = 2
+      config[:max_ticks] = 3
+    end
+    last = Time.now.to_i - 1000
+    @manager.data_store.set(@manager.data_store_key, last)
+    @manager.expects(:tick).with(last + 2).then.returns
+    @manager.expects(:tick).with(last + 4).then.returns
+    @manager.expects(:tick).with(last + 6).then.returns
+    @manager.run
+  end
+
+  it "should not tick into the future" do 
+    @manager.configure do |config|
+      config[:tick_size] = 10
+      config[:max_ticks] = 3
+    end
+    last = Time.now.to_i - 1
+    @manager.data_store.set(@manager.data_store_key, last)
+    module Failure
+      def tick 
+        raise "don't call me"
+      end 
+    end 
+    @manager.extend Failure
+    @manager.run
+  end
+
+  it "should save the last tick time" do 
+    @manager.configure do |config|
+      config[:tick_size] = 10
+      config[:max_ticks] = 1
+    end
+    last = Time.now.to_i - 1000
+    @manager.data_store.set(@manager.data_store_key, last)
+    @manager.expects(:tick).with(last + 10).then.returns
+    @manager.run
+    assert_equal (last + 10), @manager.data_store.get(@manager.data_store_key)
+  end
+
+  it "should tick from now if no last time" do 
+    @manager.configure do |config|
+      config[:tick_size] = 10
+      config[:max_ticks] = 1
+    end
+    @manager.expects(:tick).with(Time.now.to_i).then.returns
+    @manager.run
+  end
+
+  it "should be saving event last run times" do 
+    @manager.configure do |config|
+      config[:tick_size] = 10
+      config[:max_ticks] = 1
+    end
+    @manager.every(1.minute, 'myjob')
+    assert_equal 0, @manager.config[:data_store].size
+    @manager.run
+    assert_equal 2, @manager.config[:data_store].size
+    assert_equal false, @manager.config[:data_store].get('_tickwork_myjob').nil?
+  end
+
+  it "should start from max catchup when last is further in the past" do 
+    @manager.configure do |config|
+      config[:tick_size] = 1 
+      config[:max_ticks] = 1
+      config[:max_catchup] = 1800
+    end
+
+    @manager.every(1.minute, 'myjob')
+    last = Time.now.to_i - 3600
+    @manager.data_store.set(@manager.data_store_key, last)
+    @manager.expects(:tick).with(Time.now.to_i - 1800).then.returns
+    @manager.run
+  end
+
+  it "0 should disable max catchup" do 
+    @manager.configure do |config|
+      config[:tick_size] = 1 
+      config[:max_ticks] = 1
+      config[:max_catchup] = 0
+    end
+
+    @manager.every(1.minute, 'myjob')
+    last = Time.now.to_i - 36000
+    @manager.data_store.set(@manager.data_store_key, last)
+    @manager.expects(:tick).with(Time.now.to_i - 36000 + 1).then.returns
+    @manager.run
+  end
+
+  it "0 should disable max catchup" do 
+    @manager.configure do |config|
+      config[:tick_size] = 1 
+      config[:max_ticks] = 1
+      config[:max_catchup] = nil
+    end
+
+    @manager.every(1.minute, 'myjob')
+    last = Time.now.to_i - 36000
+    @manager.data_store.set(@manager.data_store_key, last)
+    @manager.expects(:tick).with(Time.now.to_i - 36000 + 1).then.returns
+    @manager.run
+  end
+
+  it "should return the last time it ran" do 
+    @manager.configure do |config|
+      config[:tick_size] = 10
+      config[:max_ticks] = 2
+    end
+    last = Time.now.to_i - 1000
+    @manager.data_store.set(@manager.data_store_key, last)
+    @manager.expects(:tick).with(last + 10).then.returns
+    @manager.expects(:tick).with(last + 20).then.returns
+    assert_equal last + 20, @manager.run
+  end
+
+  it "should clear it's datastore on #clear!" do 
+    @manager.data_store.set(@manager.data_store_key, "10")
+    @manager.clear!
+    assert_equal nil, @manager.data_store.get(@manager.data_store_key)
+  end
+
+  describe 'error_handler' do
+    before do
+      @errors = []
+      @manager.error_handler do |e|
+        @errors << e
+      end
+
+      # block error log
+      @string_io = StringIO.new
+      @manager.configure do |config|
+        config[:logger] = Logger.new(@string_io)
+      end
+      @manager.every(1.second, 'myjob') { raise 'it error' }
+    end
+
+    it 'registered error_handler handles error from event' do
+      @manager.tick
+      assert_equal ['it error'], @errors.map(&:message)
+    end
+
+    it 'error is notified to logger and handler' do
+      @manager.tick
+      assert @string_io.string.include?('it error')
+    end
+
+    it 'error in handler will NOT be suppressed' do
+      @manager.error_handler do |e|
+        raise e.message + ' re-raised'
+      end
+      assert_raises(RuntimeError, 'it error re-raised') do
+        @manager.tick
+      end
+    end
+  end
+end

data/test/null_logger.rb

@@ -0,0 +1,19 @@
+# https://github.com/karafka/null-logger/blob/master/lib/null_logger.rb
+# under MIT license as of 5/9/2016
+
+# Null logger class
+# Is used when logger is not defined
+class NullLogger
+  # Possible log levels from ruby Logger::Severity class
+  LOG_LEVELS = %w( unknown fatal error warn info debug ).freeze
+
+  # Returns nil for any method call from LOG_LEVELS array
+  # Instead raise NoMethodError
+  # @example:
+  #   NullLogger.new.fatal -> return nil
+  #   NullLogger.new.wrong_method -> raise NoMethodError
+  def method_missing(method_name, *args, &block)
+    return nil if LOG_LEVELS.include?(method_name.to_s)
+    super(method_name, *args, &block)
+  end
+end

data/test/tickwork_test.rb

@@ -0,0 +1,91 @@
+require File.expand_path('../../lib/tickwork', __FILE__)
+require File.expand_path('../data_stores/fake_store.rb', __FILE__)
+require 'minitest/autorun'
+require 'mocha/mini_test'
+
+describe Tickwork do
+def self.test_order
+   :alpha
+end
+  before do
+    @log_output = StringIO.new
+    Tickwork.configure do |config|
+      config[:logger] = Logger.new(@log_output)
+      #config[:logger] = Logger.new(STDOUT)
+      config[:data_store] = Tickwork::FakeStore.new
+    end
+  end
+
+  after do
+    Tickwork.clear!
+  end
+
+  it 'should run events with configured logger' do
+    run = false
+    Tickwork.handler do |job|
+      run = job == 'myjob'
+    end
+    Tickwork.every(1.minute, 'myjob')
+    # don't know why this doesn't work with while but did with loop
+    #Tickwork.manager.expects(:while).yields.then.returns
+    Tickwork.run
+
+    assert run
+    assert @log_output.string.include?('Triggering')
+  end
+
+  it 'should log event correctly' do
+    run = false
+    Tickwork.handler do |job|
+      run = job == 'an event'
+    end
+    Tickwork.every(1.minute, 'an event')
+    # Tickwork.manager.expects(:while).yields.then.returns
+    Tickwork.run
+    assert run
+    assert @log_output.string.include?("Triggering 'an event'")
+  end
+
+  it 'should pass event without modification to handler' do
+    event_object = 'myEvent'
+    run = false
+    Tickwork.handler do |job|
+      run = job == event_object
+    end
+    Tickwork.every(1.minute, event_object)
+    # Tickwork.manager.expects(:while).yields.then.returns
+    Tickwork.run
+    assert run
+  end
+
+  it 'should not run anything after reset' do
+    Tickwork.every(1.minute, 'myjob') {  }
+    Tickwork.clear!
+    Tickwork.configure do |config|
+      config[:sleep_timeout] = 0
+      config[:logger] = Logger.new(@log_output)
+      config[:data_store] = Tickwork::FakeStore.new
+    end
+    # Tickwork.manager.expects(:while).yields.then.returns
+    Tickwork.run
+    assert @log_output.string.include?('0 events')
+  end
+
+  it 'should pass all arguments to every' do
+    Tickwork.every(1.second, 'myjob', if: lambda { |_| false }) {  }
+    # Tickwork.manager.expects(:while).yields.then.returns
+    Tickwork.run
+    assert @log_output.string.include?('1 events')
+    assert !@log_output.string.include?('Triggering')
+  end
+
+  it 'support module re-open style' do
+    $called = false
+    module ::Tickwork
+      every(1.second, 'myjob') { $called = true }
+    end
+    # Tickwork.manager.expects(:while).yields.then.returns
+    Tickwork.run
+    assert $called
+  end
+end

data/tickworkwork.gemspec

@@ -0,0 +1,28 @@
+Gem::Specification.new do |s|
+  s.name = "tickwork"
+  s.version = "0.0.1"
+
+  s.authors = ["John Hinnegan"]
+  s.license = 'MIT'
+  s.description = "A fork of clockwork. Under development."
+  s.email = ["tickwork@johnhinnegan.com"]
+  s.extra_rdoc_files = [
+    "README.md"
+  ]
+  s.homepage = "http://github.com/softwaregravy/clockwork"
+  s.summary = "A scheduling library"
+
+  s.files         = `git ls-files`.split($/)
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+
+  s.add_dependency(%q<tzinfo>)
+  s.add_dependency(%q<activesupport>)
+
+  s.add_development_dependency "bundler", "~> 1.3"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "daemons"
+  s.add_development_dependency "minitest", "~> 5.8"
+  s.add_development_dependency "mocha"
+end