clockwork 0.7.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a05228ef038356c69ac45b0cd26eba0d9571905c
-  data.tar.gz: 1202fe6dfa6d4ed81a7850968f99d2512bf5dc5b
+  metadata.gz: 3a74c88bbd2e1b38f7c518683c73ec55b7423177
+  data.tar.gz: 45570c06ce685ab483372bd878106fe4569dd6b1
 SHA512:
-  metadata.gz: 8353beebe55670202cce99d785d646bfe239e78271f1e211b0e9379d44c785e938f17004c18e8222ec0cad389bdc35b3f5633d767555e45900d9c24c5ba8ae9f
-  data.tar.gz: c0d61cafe0c731f02f6b9c4dde2786901cf3f0b11be6e1fd86d8fadb1f73cd14493120f1d805563322e35ece1b41587a7c3c2e472712cc1db45078ff729ec9cc
+  metadata.gz: 59e7b18661134d41a859fb951e1c2e00a48b530bc9b57edd4f52a0bba46385f5f0033a001b3a7d99d8e574e7bf88bc8cb19578849d81b0e18f7b858d7250fa60
+  data.tar.gz: bd9de6f34fffc5a23a63bce5aa805bb9a01fb259c3ce07484ef4b63d7c0bca1a6b558870d0456d33bdf08ab39f75ec07605e99aa4564bc09c2051ef2e707bf54

data/.travis.yml

@@ -1,6 +1,9 @@
 rvm:
   - 1.9.3
   - 2.0.0
+  - 2.1.0
+  - jruby-19mode
+  - rbx
 gemfile:
   - gemfiles/activesupport3.gemfile
   - gemfiles/activesupport4.gemfile

data/README.md

@@ -70,13 +70,13 @@ makes it impossible to parallelize.  For doing the work, you should be using a
 job queueing system, such as
 [Delayed Job](http://www.therailsway.com/2009/7/22/do-it-later-with-delayed-job),
 [Beanstalk/Stalker](http://adam.heroku.com/past/2010/4/24/beanstalk_a_simple_and_fast_queueing_backend/),
-[RabbitMQ/Minion](http://adamblog.heroku.com/past/2009/9/28/background_jobs_with_rabbitmq_and_minion/),
+[RabbitMQ/Minion](http://adam.heroku.com/past/2009/9/28/background_jobs_with_rabbitmq_and_minion/),
 [Resque](http://github.com/blog/542-introducing-resque), or
 [Sidekiq](https://github.com/mperham/sidekiq).  This design allows a
 simple clock process with no locks, but also offers near infinite horizontal
 scalability.
 
-For example, if you're using Beanstalk/Staker:
+For example, if you're using Beanstalk/Stalker:
 
 ```ruby
 require 'stalker'
@@ -103,12 +103,22 @@ every(1.hour, 'feeds.refresh') { Feed.send_later(:refresh) }
 every(1.day, 'reminders.send', :at => '01:30') { Reminder.send_later(:send_reminders) }
 ```
 
-Parameters
+Event Parameters
 ----------
 
 ### :at
 
-`:at` parameter the hour and minute specifies when the event occur.
+`:at` parameter specifies when to trigger the event:
+
+#### Valid formats:
+
+    HH:MM
+     H:MM
+    **:MM
+    HH:**
+    (Mon|mon|Monday|monday) HH:MM
+
+#### Examples
 
 The simplest example:
 
@@ -116,13 +126,13 @@ The simplest example:
 every(1.day, 'reminders.send', :at => '01:30')
 ```
 
-You can omit 0 of the hour:
+You can omit the leading 0 of the hour:
 
 ```ruby
 every(1.day, 'reminders.send', :at => '1:30')
 ```
 
-The wildcard for hour and minute is supported:
+Wildcards for hour and minute are supported:
 
 ```ruby
 every(1.hour, 'reminders.send', :at => '**:30')
@@ -132,7 +142,7 @@ every(10.seconds, 'frequent.job', :at => '9:**')
 You can set more than one timing:
 
 ```ruby
-every(1.hour, 'reminders.send', :at => ['12:00', '18:00'])
+every(1.day, 'reminders.send', :at => ['12:00', '18:00'])
 # send reminders at noon and evening
 ```
 
@@ -142,7 +152,9 @@ You can specify the day of week to run:
 every(1.week, 'myjob', :at => 'Monday 16:20')
 ```
 
-You can also specify a timezone (default is the local timezone):
+### :tz
+
+`:tz` parameter lets you specify a timezone (default is the local timezone):
 
 ```ruby
 every(1.day, 'reminders.send', :at => '00:00', :tz => 'UTC')
@@ -171,36 +183,44 @@ Clockwork.every(1.second, 'myjob', :if => lambda { |_| true })
 
 ### :thread
 
-A handler with `:thread` parameter runs in a different thread.
+An event with `:thread => true`  runs in a different thread.
 
-If a job is long running or IO-intensive, this option will be useful to keep the clock precise.
+```ruby
+Clockwork.every(1.day, 'run.me.in.new.thread', :thread => true)
+```
+
+If a job is long-running or IO-intensive, this option helps keep the clock precise.
 
 Configuration
 -----------------------
 
-Clockwork exposes a couple of configuration options you may change:
+Clockwork exposes a couple of configuration options:
 
 ### :logger
 
-By default Clockwork logs to STDOUT. In case you prefer to make it to use our
+By default Clockwork logs to `STDOUT`. In case you prefer your
 own logger implementation you have to specify the `logger` configuration option. See example below.
 
 ### :sleep_timeout
 
-Clockwork wakes up once a second (by default) and performs its duties. If that
-is the rare case you need to tweak the number of seconds it sleeps then you have
-the `sleep_timeout` configuration option to set like shown below.
+Clockwork wakes up once a second and performs its duties. To change the number of seconds Clockwork
+sleeps, set the `sleep_timeout` configuration option as shown below in the example.
 
 ### :tz
 
 This is the default timezone to use for all events.  When not specified this defaults to the local
-timezone.  Specifying :tz in the the parameters for an event overrides anything set here.
+timezone.  Specifying :tz in the parameters for an event overrides anything set here.
 
 ### :max_threads
 
-Clockwork runs handlers in threads. If it exceeds `max_threads`, it will warn you about missing
+Clockwork runs handlers in threads. If it exceeds `max_threads`, it will warn you (log an error) about missing
 jobs.
 
+
+### :thread
+
+Boolean true or false. Default is false. If set to true, every event will be run in its own thread. Can be overridden on a per event basis (see the ```:thread``` option in the Event Parameters section above)
+
 ### Configuration example
 
 ```ruby
@@ -210,6 +230,7 @@ module Clockwork
     config[:logger] = Logger.new(log_file_path)
     config[:tz] = 'EST'
     config[:max_threads] = 15
+    config[:thread] = true
   end
 end
 ```
@@ -229,7 +250,7 @@ end
 Current specifications are as follows.
 
 - defining error_handler does not disable original logging
-- errors from error_handler itself do not rescued, and stop clockwork
+- errors from error_handler itself are not rescued, and stop clockwork
 
 Any suggestion about these specifications is welcome.
 
@@ -237,7 +258,7 @@ Old style
 ---------
 
 `include Clockwork` is old style.
-That is still supported, but not recommended, because it taint global namespace.
+The old style is still supported, though not recommended, because it pollutes the global namespace.
 
 
 
@@ -246,8 +267,7 @@ Anatomy of a clock file
 
 clock.rb is standard Ruby.  Since we include the Clockwork module (the
 clockwork binary does this automatically, or you can do it explicitly), this
-exposes a small DSL ("handler" and "every") to define the handler for events,
-and then the events themselves.
+exposes a small DSL to define the handler for events, and then the events themselves.
 
 The handler typically looks like this:
 
@@ -259,7 +279,7 @@ This block will be invoked every time an event is triggered, with the job name
 passed in.  In most cases, you should be able to pass the job name directly
 through to your queueing system.
 
-The second part of the file are the events, which roughly resembles a crontab:
+The second part of the file, which lists the events, roughly resembles a crontab:
 
 ```ruby
 every(5.minutes, 'thing.do')
@@ -286,7 +306,21 @@ You can also use blocks to do more complex checks:
 
 ```ruby
 every(1.day, 'check.leap.year') do
-  Stalker.enqueue('leap.year.party') if Time.now.year % 4 == 0
+  Stalker.enqueue('leap.year.party') if Date.leap?(Time.now.year)
+end
+```
+
+In addition, Clockwork also supports `:before_tick` and `after_tick` callbacks.
+They are optional, and run every tick (a tick being whatever your `:sleep_timeout`
+is set to, default is 1 second):
+
+```ruby
+on(:before_tick) do
+  puts "tick"
+end
+
+on(:after_tick) do
+  puts "tock"
 end
 ```
 
@@ -307,9 +341,9 @@ running the same way you keep your web and workers running.
 Daemonization
 -------------
 
-Thanks to @fddayan, `clockworkd` executes clockwork script in as a daemon.
+Thanks to @fddayan, `clockworkd` executes clockwork script as a daemon.
 
-You need `daemons` gem to use `clockworkd`.  It is not automatically installed, please install by yourself.
+You will need the `daemons` gem to use `clockworkd`.  It is not automatically installed, please install by yourself.
 
 Then,
 
@@ -322,15 +356,15 @@ For more details, see help shown by `clockworkd`.
 Issues and Pull requests
 ------------------------
 
-Let us know bugs you found as an issue from [Issues · tomykaira/clockwork](https://github.com/tomykaira/clockwork/issues).
+If you find a bug, please create an issue - [Issues · tomykaira/clockwork](https://github.com/tomykaira/clockwork/issues).
 
 For a bug fix or a feature request, please send a pull-request.
 Do not forget to add tests to show how your feature works, or what bug is fixed.
 All existing tests and new tests must pass (TravisCI is watching).
 
 We want to provide simple and customizable core, so superficial changes will not be merged (e.g. supporting new event registration style).
-In most case, directly operating `Manager` realizes an idea, without touching the core.
-If you get up with a new usage, please create a gist page or an article on your website, then add to the following "Use cases" section.
+In most cases, directly operating `Manager` realizes an idea, without touching the core.
+If you discover a new way to use Clockwork, please create a gist page or an article on your website, then add it to the following "Use cases" section.
 This tool is already used in various environment, so backward-incompatible requests will be mostly rejected.
 
 Use cases

data/clockwork.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "clockwork"
-  s.version = "0.7.0"
+  s.version = "0.7.1"
 
   s.authors = ["Adam Wiggins", "tomykaira"]
   s.license = 'MIT'

data/example.rb

@@ -14,4 +14,15 @@ module Clockwork
   every(1.day, 'custom.event.handler', :at => '00:30') do
     puts 'This event has its own handler'
   end
+
+  # note: callbacks that return nil or false will cause event to not run
+  on(:before_tick) do
+    puts "tick"
+    true
+  end
+
+  on(:after_tick) do
+    puts "tock"
+    true
+  end
 end

data/gemfiles/activesupport3.gemfile

@@ -1,4 +1,10 @@
 source 'https://rubygems.org'
 
+platforms :rbx do
+  gem 'rubysl', '~> 2.0'
+  gem 'rubysl-test-unit'
+  gem 'rubinius-developer_tools'
+end
+
 gem 'activesupport', '~> 3.2.14'
 gemspec :path=>"../"

data/gemfiles/activesupport4.gemfile

@@ -1,4 +1,10 @@
 source 'https://rubygems.org'
 
+platforms :rbx do
+  gem 'rubysl', '~> 2.0'
+  gem 'rubysl-test-unit'
+  gem 'rubinius-developer_tools'
+end
+
 gem 'activesupport', '~> 4.0.0'
 gemspec :path=>"../"

data/lib/clockwork/at.rb

@@ -3,19 +3,23 @@ module Clockwork
     class FailedToParse < StandardError; end
 
     NOT_SPECIFIED = nil
-    WDAYS = %w[sunday monday tuesday wednesday thursday friday saturday].map do |w|
-      [w, w.capitalize, w[0...3], w[0...3].capitalize]
+    WDAYS = %w[sunday monday tuesday wednesday thursday friday saturday].each.with_object({}).with_index do |(w, wdays), index|
+      [w, w.capitalize, w[0...3], w[0...3].capitalize].each do |k|
+        wdays[k] = index
+      end
     end
 
     def self.parse(at)
       return unless at
       case at
       when /^([[:alpha:]]+)\s(.*)$/
-        ret = parse($2)
-        wday = WDAYS.find_index { |x| x.include?($1) }
-        raise FailedToParse, at if wday.nil?
-        ret.wday = wday
-        ret
+        if wday = WDAYS[$1]
+          parsed_time = parse($2)
+          parsed_time.wday = wday
+          parsed_time
+        else
+          raise FailedToParse, at
+        end
       when /^(\d{1,2}):(\d\d)$/
         new($2.to_i, $1.to_i)
       when /^\*{1,2}:(\d\d)$/
@@ -32,14 +36,10 @@ module Clockwork
     attr_writer :min, :hour, :wday
 
     def initialize(min, hour=NOT_SPECIFIED, wday=NOT_SPECIFIED)
-      if (min != NOT_SPECIFIED && (min < 0 || min > 59)) ||
-          (hour != NOT_SPECIFIED && (hour < 0 || hour > 23)) ||
-          (wday != NOT_SPECIFIED && (wday < 0 || wday > 6))
-        raise ArgumentError
-      end
       @min = min
       @hour = hour
       @wday = wday
+      raise ArgumentError unless valid?
     end
 
     def ready?(t)
@@ -47,5 +47,12 @@ module Clockwork
         (@hour == NOT_SPECIFIED or t.hour == @hour) and
         (@wday == NOT_SPECIFIED or t.wday == @wday)
     end
+
+    private
+    def valid?
+      @min == NOT_SPECIFIED || (0..59).cover?(@min) &&
+        @hour == NOT_SPECIFIED || (0..23).cover?(@hour) &&
+        @wday == NOT_SPECIFIED || (0..6).cover?(@wday)
+    end
   end
 end

data/lib/clockwork/event.rb

@@ -3,6 +3,7 @@ module Clockwork
     attr_accessor :job, :last
 
     def initialize(manager, period, job, block, options={})
+      validate_if_option(options[:if])
       @manager = manager
       @period = period
       @job = job
@@ -10,22 +11,17 @@ module Clockwork
       @last = nil
       @block = block
       @if = options[:if]
-      @thread = options[:thread]
-      @timezone = options[:tz]
-    end
-
-    def to_s
-      @job
+      @thread = options.fetch(:thread, @manager.config[:thread])
+      @timezone = options.fetch(:tz, @manager.config[:tz])
     end
 
     def convert_timezone(t)
       @timezone ? t.in_time_zone(@timezone) : t
     end
 
-    def time?(t)
+    def run_now?(t)
       t = convert_timezone(t)
-      elapsed_ready = (@last.nil? or (t - @last).to_i >= @period)
-      elapsed_ready and (@at.nil? or @at.ready?(t)) and (@if.nil? or @if.call(t))
+      elapsed_ready(t) and (@at.nil? or @at.ready?(t)) and (@if.nil? or @if.call(t))
     end
 
     def thread?
@@ -33,45 +29,38 @@ module Clockwork
     end
 
     def run(t)
-      t = convert_timezone(t)
-      @last = t
-
+      @manager.log "Triggering '#{self}'"
+      @last = convert_timezone(t)
       if thread?
         if @manager.thread_available?
           Thread.new { execute }
         else
-          log_error "Threads exhausted; skipping #{self}"
+          @manager.log_error "Threads exhausted; skipping #{self}"
         end
       else
         execute
       end
     end
 
+    def to_s
+      job.to_s
+    end
+
+    private
     def execute
       @block.call(@job, @last)
     rescue => e
-      log_error e
-      handle_error e
-    end
-
-    def log_error(e)
-      @manager.config[:logger].error(e)
+      @manager.log_error e
+      @manager.handle_error e
     end
 
-    def exception_message(e)
-      msg = [ "Exception #{e.class} -> #{e.message}" ]
-
-      base = File.expand_path(Dir.pwd) + '/'
-      e.backtrace.each do |t|
-        msg << "   #{File.expand_path(t).gsub(/#{base}/, '')}"
-      end
-
-      msg.join("\n")
+    def elapsed_ready(t)
+      @last.nil? || (t - @last).to_i >= @period
     end
 
-    def handle_error(e)
-      if handler = @manager.get_error_handler
-        handler.call(e)
+    def validate_if_option(if_option)
+      if if_option && !if_option.respond_to?(:call)
+        raise ArgumentError.new(':if expects a callable object, but #{if_option} does not respond to call')
       end
     end
   end

data/lib/clockwork/manager.rb

@@ -24,19 +24,13 @@ module Clockwork
     end
 
     def handler(&block)
-      @handler = block
-    end
-
-    def get_handler
-      raise NoHandlerDefined unless (defined?(@handler) and @handler)
+      @handler = block if block_given?
+      raise NoHandlerDefined unless @handler
       @handler
     end
 
     def error_handler(&block)
-      @error_handler = block
-    end
-
-    def get_error_handler
+      @error_handler = block if block_given?
       @error_handler
     end
 
@@ -58,7 +52,7 @@ module Clockwork
     end
 
     def run
-      log "Starting clock for #{@events.size} events: [ " + @events.map { |e| e.to_s }.join(' ') + " ]"
+      log "Starting clock for #{@events.size} events: [ #{@events.map(&:to_s).join(' ')} ]"
       loop do
         tick
         sleep(config[:sleep_timeout])
@@ -67,47 +61,41 @@ module Clockwork
 
     def tick(t=Time.now)
       if (fire_callbacks(:before_tick))
-        to_run = @events.select do |event|
-          event.time?(t)
-        end
-
-        to_run.each do |event|
+        events = events_to_run(t)
+        events.each do |event|
           if (fire_callbacks(:before_run, event, t))
-            log "Triggering '#{event}'"
             event.run(t)
             fire_callbacks(:after_run, event, t)
           end
         end
       end
-
       fire_callbacks(:after_tick)
-      to_run
+      events
+    end
+
+    def log_error(e)
+      config[:logger].error(e)
+    end
+
+    def handle_error(e)
+      error_handler.call(e) if error_handler
     end
 
-    private
     def log(msg)
       config[:logger].info(msg)
     end
 
+    private
+    def events_to_run(t)
+      @events.select{ |event| event.run_now?(t) }
+    end
+
     def register(period, job, block, options)
-      event = Event.new(self, period, job, block || get_handler, parse_event_option(options))
+      event = Event.new(self, period, job, block || handler, options)
       @events << event
       event
     end
 
-    def parse_event_option(options)
-      if options[:if]
-        if !options[:if].respond_to?(:call)
-          raise ArgumentError.new(':if expects a callable object, but #{options[:if]} does not respond to call')
-        end
-      end
-
-      options[:thread] = !!(options.has_key?(:thread) ? options[:thread] : config[:thread])
-      options[:tz] ||= config[:tz]
-
-      options
-    end
-
     def every_with_multiple_times(period, job, options={}, &block)
       each_options = options.clone
       options[:at].each do |at|

data/test/at_test.rb

@@ -84,4 +84,10 @@ class AtTest < Test::Unit::TestCase
     assert  at.ready?(Time.new(2010, 1, 2, 12, 00))
     assert !at.ready?(Time.new(2010, 1, 3, 12, 00))
   end
+
+  test 'invalid time 32:00' do
+    assert_raise Clockwork::At::FailedToParse do
+      Clockwork::At.parse('32:00')
+    end
+  end
 end

data/test/clockwork_test.rb

@@ -1,8 +1,14 @@
 require File.expand_path('../../lib/clockwork', __FILE__)
 require 'contest'
-require 'timeout'
+require 'mocha/setup'
 
 class ClockworkTest < Test::Unit::TestCase
+  setup do
+    Clockwork.configure do |config|
+      config[:sleep_timeout] = 0
+    end
+  end
+
   teardown do
     Clockwork.clear!
   end
@@ -15,12 +21,6 @@ class ClockworkTest < Test::Unit::TestCase
     string_io
   end
 
-  def run_in_thread
-    Thread.new do
-      Clockwork.run
-    end
-  end
-
   test 'should run events with configured logger' do
     run = false
     string_io = set_string_io_logger
@@ -28,34 +28,55 @@ class ClockworkTest < Test::Unit::TestCase
       run = job == 'myjob'
     end
     Clockwork.every(1.minute, 'myjob')
+    Clockwork.manager.expects(:loop).yields.then.returns
+    Clockwork.run
+    assert run
+    assert string_io.string.include?('Triggering')
+  end
 
-    runner = run_in_thread
+  test 'should log event correctly' do
+    run = false
+    string_io = set_string_io_logger
+    Clockwork.handler do |job|
+      run = job == 'an event'
+    end
+    Clockwork.every(1.minute, 'an event')
+    Clockwork.manager.expects(:loop).yields.then.returns
+    Clockwork.run
+    assert run
+    assert string_io.string.include?("Triggering 'an event'")
+  end
 
-    timeout(5) do
-      sleep 1 until run
+  test 'should pass event without modification to handler' do
+    event_object = Object.new
+    run = false
+    string_io = set_string_io_logger
+    Clockwork.handler do |job|
+      run = job == event_object
     end
-    runner.kill
+    Clockwork.every(1.minute, event_object)
+    Clockwork.manager.expects(:loop).yields.then.returns
+    Clockwork.run
     assert run
-    assert string_io.string.include?('Triggering')
   end
 
   test 'should not run anything after reset' do
     Clockwork.every(1.minute, 'myjob') {  }
     Clockwork.clear!
-
+    Clockwork.configure do |config|
+      config[:sleep_timeout] = 0
+    end
     string_io = set_string_io_logger
-    runner = run_in_thread
-    sleep 1
-    runner.kill
+    Clockwork.manager.expects(:loop).yields.then.returns
+    Clockwork.run
     assert string_io.string.include?('0 events')
   end
 
   test 'should pass all arguments to every' do
-    Clockwork.every(1.second, 'myjob', if: lambda { false }) {  }
+    Clockwork.every(1.second, 'myjob', if: lambda { |_| false }) {  }
     string_io = set_string_io_logger
-    runner = run_in_thread
-    sleep 1
-    runner.kill
+    Clockwork.manager.expects(:loop).yields.then.returns
+    Clockwork.run
     assert string_io.string.include?('1 events')
     assert !string_io.string.include?('Triggering')
   end
@@ -66,10 +87,8 @@ class ClockworkTest < Test::Unit::TestCase
       every(1.second, 'myjob') { $called = true }
     end
     set_string_io_logger
-    runner = run_in_thread
-    sleep 1
-    runner.kill
-
+    Clockwork.manager.expects(:loop).yields.then.returns
+    Clockwork.run
     assert $called
   end
 end

data/test/event_test.rb

@@ -0,0 +1,37 @@
+require File.expand_path('../../lib/clockwork', __FILE__)
+require 'contest'
+
+class EventTest < Test::Unit::TestCase
+  describe "#thread?" do
+    setup do
+      @manager = mock
+    end
+
+    describe "manager config thread option set to true" do
+      setup do
+        @manager.stubs(:config).returns({ :thread => true })
+      end
+
+      test "is true" do
+        event = Clockwork::Event.new(@manager, nil, nil, nil)
+        assert_equal true, event.thread?
+      end
+
+      test "is false when event thread option set" do
+        event = Clockwork::Event.new(@manager, nil, nil, nil, :thread => false)
+        assert_equal false, event.thread?
+      end
+    end
+
+    describe "manager config thread option not set" do
+      setup do
+        @manager.stubs(:config).returns({})
+      end
+
+      test "is true if event thread option is true" do
+        event = Clockwork::Event.new(@manager, nil, nil, nil, :thread => true)
+        assert_equal true, event.thread?
+      end
+    end
+  end
+end

data/test/manager_test.rb

@@ -122,7 +122,7 @@ class ManagerTest < Test::Unit::TestCase
   test "exceptions still set the last timestamp to avoid spastic error loops" do
     @manager.handler { raise 'boom' }
     event = @manager.every(1.minute, 'myjob')
-    event.stubs(:log_error)
+    @manager.stubs(:log_error)
     @manager.tick(t = Time.now)
     assert_equal t, event.last
   end
@@ -173,6 +173,10 @@ class ManagerTest < Test::Unit::TestCase
   end
 
   describe ':tz option' do
+    test "time zone is not set by default" do
+      assert @manager.config[:tz].nil?
+    end
+
     test "should be able to specify a different timezone than local" do
       @manager.every(1.day, 'myjob', :at => '10:00', :tz => 'UTC')
 
@@ -256,36 +260,6 @@ class ManagerTest < Test::Unit::TestCase
     @manager.tick(Time.now)
   end
 
-  describe "thread option" do
-    test "should not use thread by default" do
-      event = @manager.every(1.minute, 'myjob')
-      assert !event.thread?
-    end
-
-    test "should use thread if thread option is specified with truly value" do
-      event = @manager.every(1.minute, 'myjob', :thread => true)
-      assert event.thread?
-    end
-
-    test "should use thread if global thread option is set" do
-      @manager.configure do |config|
-        config[:thread] = true
-      end
-
-      event = @manager.every(1.minute, 'myjob')
-      assert event.thread?
-    end
-
-    test "should not use thread if job option overrides global option" do
-      @manager.configure do |config|
-        config[:thread] = true
-      end
-
-      event = @manager.every(1.minute, 'myjob', :thread => false)
-      assert !event.thread?
-    end
-  end
-
   describe "callbacks" do
     test "should not accept unknown callback name" do
       assert_raise(RuntimeError, "Unsupported callback unknown_callback") do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: clockwork
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Adam Wiggins
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-31 00:00:00.000000000 Z
+date: 2014-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tzinfo
@@ -138,6 +138,7 @@ files:
 - lib/clockwork/manager.rb
 - test/at_test.rb
 - test/clockwork_test.rb
+- test/event_test.rb
 - test/manager_test.rb
 homepage: http://github.com/tomykaira/clockwork
 licenses:
@@ -166,4 +167,5 @@ summary: A scheduler process to replace cron.
 test_files:
 - test/at_test.rb
 - test/clockwork_test.rb
+- test/event_test.rb
 - test/manager_test.rb