clockwork 1.2.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a1c0df23cd1bd9f2a974f5d5461b162d5449858b
-  data.tar.gz: 57d4d055c37fea9164a51ea16afb34cf72b6ca16
+  metadata.gz: c0e853cc4ad85d5e3814beac451289db63f3cfdf
+  data.tar.gz: 4d5b4f49d461f7a2b9e6670d122cc74c3d3ee1dc
 SHA512:
-  metadata.gz: 61a97fce154912af62947c6591f771ce532e1b87bc4b25cd83d6983ac2d1618ebe9c98a4c2df7cc939a3af2d04aa9bef6b29169f3b38ca07eb63fece32a97fdc
-  data.tar.gz: f9a24be2f061626b409b69fa43f53b0ee16da421d892a5b5afd4bc86623ce41e74ab598bf0b89a9451c42c0279cc76314b92f8fb1706922312cdf51c53092dee
+  metadata.gz: cdc0a27e31a8c45dc07aeedf1cb5c80e0983bb25dfee570568d91147a6b54d8524efc5d7ccc580f9a9ae09e0dd4126f562951a997864d142617ca44b3d4a3c2b
+  data.tar.gz: 68a028033d71834bd0c1904de8dfeaab9624593f1211cb9254483835c71489c7936ec9ffecef30fc70f5dd62884752b35b4c58575ab89dbbe5338eb8db4e77a4

data/clockwork.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "clockwork"
-  s.version = "1.2.0"
+  s.version = "1.2.1"
 
   s.authors = ["Adam Wiggins", "tomykaira"]
   s.license = 'MIT'
@@ -23,7 +23,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency "bundler", "~> 1.3"
   s.add_development_dependency "rake"
   s.add_development_dependency "daemons"
-  s.add_development_dependency "test-unit"
-  s.add_development_dependency "minitest", "~> 4.0"
+  s.add_development_dependency "minitest", "~> 5.8"
   s.add_development_dependency "mocha"
 end

data/gemfiles/activesupport4.gemfile

@@ -7,4 +7,5 @@ platforms :rbx do
 end
 
 gem 'activesupport', '~> 4.0.0'
+gem 'minitest', '~> 4.2'
 gemspec :path=>"../"

data/test/at_test.rb

@@ -1,31 +1,29 @@
 require File.expand_path('../../lib/clockwork', __FILE__)
-require 'rubygems'
-require 'test/unit'
+require "minitest/autorun"
 require 'mocha/setup'
 require 'time'
 require 'active_support/time'
-require 'active_support/test_case'
 
-class AtTest < ActiveSupport::TestCase
+describe 'Clockwork::At' do
   def time_in_day(hour, minute)
     Time.new(2013, 1, 1, hour, minute, 0)
   end
 
-  test '16:20' do
+  it '16:20' do
     at = Clockwork::At.parse('16:20')
     assert !at.ready?(time_in_day(16, 19))
     assert  at.ready?(time_in_day(16, 20))
     assert !at.ready?(time_in_day(16, 21))
   end
 
-  test '8:20' do
+  it '8:20' do
     at = Clockwork::At.parse('8:20')
     assert !at.ready?(time_in_day(8, 19))
     assert  at.ready?(time_in_day(8, 20))
     assert !at.ready?(time_in_day(8, 21))
   end
 
-  test '**:20 with two stars' do
+  it '**:20 with two stars' do
     at = Clockwork::At.parse('**:20')
 
     assert !at.ready?(time_in_day(15, 19))
@@ -37,7 +35,7 @@ class AtTest < ActiveSupport::TestCase
     assert !at.ready?(time_in_day(16, 21))
   end
 
-  test '*:20 with one star' do
+  it '*:20 with one star' do
     at = Clockwork::At.parse('*:20')
 
     assert !at.ready?(time_in_day(15, 19))
@@ -49,7 +47,7 @@ class AtTest < ActiveSupport::TestCase
     assert !at.ready?(time_in_day(16, 21))
   end
 
-  test '16:**' do
+  it '16:**' do
     at = Clockwork::At.parse('16:**')
 
     assert !at.ready?(time_in_day(15, 59))
@@ -59,7 +57,7 @@ class AtTest < ActiveSupport::TestCase
     assert !at.ready?(time_in_day(17, 00))
   end
 
-  test '8:**' do
+  it '8:**' do
     at = Clockwork::At.parse('8:**')
 
     assert !at.ready?(time_in_day(7, 59))
@@ -69,7 +67,7 @@ class AtTest < ActiveSupport::TestCase
     assert !at.ready?(time_in_day(9, 00))
   end
 
-  test 'Saturday 12:00' do
+  it 'Saturday 12:00' do
     at = Clockwork::At.parse('Saturday 12:00')
 
     assert !at.ready?(Time.new(2010, 1, 1, 12, 00))
@@ -78,7 +76,7 @@ class AtTest < ActiveSupport::TestCase
     assert  at.ready?(Time.new(2010, 1, 9, 12, 00))
   end
 
-  test 'sat 12:00' do
+  it 'sat 12:00' do
     at = Clockwork::At.parse('sat 12:00')
 
     assert !at.ready?(Time.new(2010, 1, 1, 12, 00))
@@ -86,34 +84,33 @@ class AtTest < ActiveSupport::TestCase
     assert !at.ready?(Time.new(2010, 1, 3, 12, 00))
   end
 
-  test 'invalid time 32:00' do
-    assert_raise Clockwork::At::FailedToParse do
+  it 'invalid time 32:00' do
+    assert_raises Clockwork::At::FailedToParse do
       Clockwork::At.parse('32:00')
     end
   end
 
-  test 'invalid multi-line with Sat 12:00' do
-    assert_raise Clockwork::At::FailedToParse do
+  it 'invalid multi-line with Sat 12:00' do
+    assert_raises Clockwork::At::FailedToParse do
       Clockwork::At.parse("sat 12:00\nreally invalid time")
     end
   end
 
-  test 'invalid multi-line with 8:30' do
-    assert_raise Clockwork::At::FailedToParse do
+  it 'invalid multi-line with 8:30' do
+    assert_raises Clockwork::At::FailedToParse do
       Clockwork::At.parse("8:30\nreally invalid time")
     end
   end
 
-  test 'invalid multi-line with *:10' do
-    assert_raise Clockwork::At::FailedToParse do
+  it 'invalid multi-line with *:10' do
+    assert_raises Clockwork::At::FailedToParse do
       Clockwork::At.parse("*:10\nreally invalid time")
     end
   end
 
-  test 'invalid multi-line with 12:**' do
-    assert_raise Clockwork::At::FailedToParse do
+  it 'invalid multi-line with 12:**' do
+    assert_raises Clockwork::At::FailedToParse do
       Clockwork::At.parse("12:**\nreally invalid time")
     end
   end
-
 end

data/test/clockwork_test.rb

@@ -1,9 +1,9 @@
 require File.expand_path('../../lib/clockwork', __FILE__)
-require 'test/unit'
+require 'minitest/autorun'
 require 'mocha/setup'
 
-class ClockworkTest < Test::Unit::TestCase
-  setup do
+describe Clockwork do
+  before do
     @log_output = StringIO.new
     Clockwork.configure do |config|
       config[:sleep_timeout] = 0
@@ -11,11 +11,11 @@ class ClockworkTest < Test::Unit::TestCase
     end
   end
 
-  teardown do
+  after do
     Clockwork.clear!
   end
 
-  test 'should run events with configured logger' do
+  it 'should run events with configured logger' do
     run = false
     Clockwork.handler do |job|
       run = job == 'myjob'
@@ -23,11 +23,12 @@ class ClockworkTest < Test::Unit::TestCase
     Clockwork.every(1.minute, 'myjob')
     Clockwork.manager.expects(:loop).yields.then.returns
     Clockwork.run
+
     assert run
     assert @log_output.string.include?('Triggering')
   end
 
-  test 'should log event correctly' do
+  it 'should log event correctly' do
     run = false
     Clockwork.handler do |job|
       run = job == 'an event'
@@ -39,7 +40,7 @@ class ClockworkTest < Test::Unit::TestCase
     assert @log_output.string.include?("Triggering 'an event'")
   end
 
-  test 'should pass event without modification to handler' do
+  it 'should pass event without modification to handler' do
     event_object = Object.new
     run = false
     Clockwork.handler do |job|
@@ -51,7 +52,7 @@ class ClockworkTest < Test::Unit::TestCase
     assert run
   end
 
-  test 'should not run anything after reset' do
+  it 'should not run anything after reset' do
     Clockwork.every(1.minute, 'myjob') {  }
     Clockwork.clear!
     Clockwork.configure do |config|
@@ -63,7 +64,7 @@ class ClockworkTest < Test::Unit::TestCase
     assert @log_output.string.include?('0 events')
   end
 
-  test 'should pass all arguments to every' do
+  it 'should pass all arguments to every' do
     Clockwork.every(1.second, 'myjob', if: lambda { |_| false }) {  }
     Clockwork.manager.expects(:loop).yields.then.returns
     Clockwork.run
@@ -71,7 +72,7 @@ class ClockworkTest < Test::Unit::TestCase
     assert !@log_output.string.include?('Triggering')
   end
 
-  test 'support module re-open style' do
+  it 'support module re-open style' do
     $called = false
     module ::Clockwork
       every(1.second, 'myjob') { $called = true }

data/test/database_events/sync_performer_test.rb

@@ -1,297 +1,290 @@
-require 'test/unit'
+require "minitest/autorun"
 require 'mocha/setup'
 require 'time'
 require 'active_support/time'
-require 'active_support/test_case'
 
 require_relative '../../lib/clockwork'
 require_relative '../../lib/clockwork/database_events'
 require_relative 'test_helpers'
 
-module DatabaseEvents
+describe Clockwork::DatabaseEvents::SyncPerformer do
+  before do
+    @now = Time.now
+    DatabaseEventModel.delete_all
+    DatabaseEventModel2.delete_all
 
-  class SyncPerformerTest < ActiveSupport::TestCase
-
-    setup do
-      @now = Time.now
-      DatabaseEventModel.delete_all
-      DatabaseEventModel2.delete_all
-
-      Clockwork.manager = @manager = Clockwork::DatabaseEvents::Manager.new
-      class << @manager
-        def log(msg); end # silence log output
-      end
+    Clockwork.manager = @manager = Clockwork::DatabaseEvents::Manager.new
+    class << @manager
+      def log(msg); end # silence log output
     end
+  end
 
-    describe "setup" do
-      setup do
-        @subject = Clockwork::DatabaseEvents::SyncPerformer
-      end
+  after do
+    Clockwork.clear!
+  end
 
-      describe "arguments" do
-        def test_does_not_raise_error_with_valid_arguments
-          @subject.setup(model: DatabaseEventModel, every: 1.minute) {}
-        end
+  describe "setup" do
+    before do
+      @subject = Clockwork::DatabaseEvents::SyncPerformer
+    end
 
-        def test_raises_argument_error_if_model_is_not_set
-          error = assert_raises KeyError do
-            @subject.setup(every: 1.minute) {}
-          end
-          assert_equal error.message, ":model must be set to the model class"
+    describe "arguments" do
+      it 'raises argument error if model is not set' do
+        error = assert_raises KeyError do
+          @subject.setup(every: 1.minute) {}
         end
+        assert_equal error.message, ":model must be set to the model class"
+      end
 
-        def test_raises_argument_error_if_every_is_not_set
-          error = assert_raises KeyError do
-            @subject.setup(model: DatabaseEventModel) {}
-          end
-          assert_equal error.message, ":every must be set to the database sync frequency"
+      it 'raises argument error if every is not set' do
+        error = assert_raises KeyError do
+          @subject.setup(model: DatabaseEventModel) {}
         end
+        assert_equal error.message, ":every must be set to the database sync frequency"
       end
+    end
 
-      context "when database reload frequency is greater than model frequency period" do
-        setup do
-          @events_run = []
-          @sync_frequency = 1.minute
-        end
+    describe "when database reload frequency is greater than model frequency period" do
+      before do
+        @events_run = []
+        @sync_frequency = 1.minute
+      end
 
-        def test_fetches_and_registers_event_from_database
-          DatabaseEventModel.create(:frequency => 10)
-          setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
+      it 'fetches and registers event from database' do
+        DatabaseEventModel.create(:frequency => 10)
+        setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
 
-          tick_at(@now, :and_every_second_for => 1.second)
+        tick_at(@now, :and_every_second_for => 1.second)
 
-          assert_equal ["DatabaseEventModel:1"], @events_run
-        end
+        assert_equal ["DatabaseEventModel:1"], @events_run
+      end
 
-        def test_multiple_events_from_database_can_be_registered
-          DatabaseEventModel.create(:frequency => 10)
-          DatabaseEventModel.create(:frequency => 10)
-          setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
+      it 'fetches and registers multiple events from database' do
+        DatabaseEventModel.create(:frequency => 10)
+        DatabaseEventModel.create(:frequency => 10)
+        setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
 
-          tick_at(@now, :and_every_second_for => 1.second)
+        tick_at(@now, :and_every_second_for => 1.second)
 
-          assert_equal ["DatabaseEventModel:1", "DatabaseEventModel:2"], @events_run
-        end
+        assert_equal ["DatabaseEventModel:1", "DatabaseEventModel:2"], @events_run
+      end
 
-        def test_event_from_database_does_not_run_again_before_frequency_specified_in_database
-          model = DatabaseEventModel.create(:frequency => 10)
-          setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
+      it 'does not run event again before frequency specified in database' do
+        model = DatabaseEventModel.create(:frequency => 10)
+        setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
 
-          tick_at(@now, :and_every_second_for => model.frequency - 1.second)
-          assert_equal 1, @events_run.length
-        end
+        tick_at(@now, :and_every_second_for => model.frequency - 1.second)
+        assert_equal 1, @events_run.length
+      end
 
-        def test_event_from_database_runs_repeatedly_with_frequency_specified_in_database
-          model = DatabaseEventModel.create(:frequency => 10)
-          setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
+      it 'runs event repeatedly with frequency specified in database' do
+        model = DatabaseEventModel.create(:frequency => 10)
+        setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
 
-          tick_at(@now, :and_every_second_for => (2 * model.frequency) + 1.second)
+        tick_at(@now, :and_every_second_for => (2 * model.frequency) + 1.second)
 
-          assert_equal 3, @events_run.length
-        end
+        assert_equal 3, @events_run.length
+      end
 
-        def test_reloaded_events_from_database_run_repeatedly
-          model = DatabaseEventModel.create(:frequency => 10)
-          setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
+      it 'runs reloaded events from database repeatedly' do
+        model = DatabaseEventModel.create(:frequency => 10)
+        setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
 
-          tick_at(@now, :and_every_second_for => @sync_frequency - 1)
-          model.update(:name => "DatabaseEventModel:1:Reloaded")
-          tick_at(@now + @sync_frequency, :and_every_second_for => model.frequency * 2)
+        tick_at(@now, :and_every_second_for => @sync_frequency - 1)
+        model.update(:name => "DatabaseEventModel:1:Reloaded")
+        tick_at(@now + @sync_frequency, :and_every_second_for => model.frequency * 2)
 
-          assert_equal ["DatabaseEventModel:1:Reloaded", "DatabaseEventModel:1:Reloaded"], @events_run[-2..-1]
-        end
+        assert_equal ["DatabaseEventModel:1:Reloaded", "DatabaseEventModel:1:Reloaded"], @events_run[-2..-1]
+      end
 
-        def test_reloading_events_from_database_with_modified_frequency_will_run_with_new_frequency
-          model = DatabaseEventModel.create(:frequency => 10)
-          setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
+      it 'updates modified event frequency with event reloading' do
+        model = DatabaseEventModel.create(:frequency => 10)
+        setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
 
-          tick_at(@now, :and_every_second_for => @sync_frequency - 1.second)
-          model.update(:frequency => 5)
-          tick_at(@now + @sync_frequency, :and_every_second_for => 6.seconds)
+        tick_at(@now, :and_every_second_for => @sync_frequency - 1.second)
+        model.update(:frequency => 5)
+        tick_at(@now + @sync_frequency, :and_every_second_for => 6.seconds)
 
-          # model runs at: 1, 11, 21, 31, 41, 51 (6 runs)
-          # database sync happens at: 60
-          # modified model runs at: 61 (next tick after reload) and then 66 (2 runs)
-          assert_equal 8, @events_run.length
-        end
+        # model runs at: 1, 11, 21, 31, 41, 51 (6 runs)
+        # database sync happens at: 60
+        # modified model runs at: 61 (next tick after reload) and then 66 (2 runs)
+        assert_equal 8, @events_run.length
+      end
 
-        def test_stops_running_deleted_events_from_database
-          model = DatabaseEventModel.create(:frequency => 10)
-          setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
+      it 'stoped running deleted events from database' do
+        model = DatabaseEventModel.create(:frequency => 10)
+        setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
 
-          tick_at(@now, :and_every_second_for => (@sync_frequency - 1.second))
-          before = @events_run.dup
-          model.delete!
-          tick_at(@now + @sync_frequency, :and_every_second_for => @sync_frequency)
-          after = @events_run
+        tick_at(@now, :and_every_second_for => (@sync_frequency - 1.second))
+        before = @events_run.dup
+        model.delete!
+        tick_at(@now + @sync_frequency, :and_every_second_for => @sync_frequency)
+        after = @events_run
 
-          assert_equal before, after
-        end
+        assert_equal before, after
+      end
 
-        def test_event_from_database_with_edited_name_switches_to_new_name
-          model = DatabaseEventModel.create(:frequency => 10.seconds)
-          setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
+      it 'updates event name with new name' do
+        model = DatabaseEventModel.create(:frequency => 10.seconds)
+        setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
 
-          tick_at @now, :and_every_second_for => @sync_frequency - 1.second
-          @events_run.clear
-          model.update(:name => "DatabaseEventModel:1_modified")
-          tick_at @now + @sync_frequency, :and_every_second_for => (model.frequency * 2)
+        tick_at @now, :and_every_second_for => @sync_frequency - 1.second
+        @events_run.clear
+        model.update(:name => "DatabaseEventModel:1_modified")
+        tick_at @now + @sync_frequency, :and_every_second_for => (model.frequency * 2)
 
-          assert_equal ["DatabaseEventModel:1_modified", "DatabaseEventModel:1_modified"], @events_run
-        end
+        assert_equal ["DatabaseEventModel:1_modified", "DatabaseEventModel:1_modified"], @events_run
+      end
 
-        def test_event_from_database_with_edited_frequency_switches_to_new_frequency
-          model = DatabaseEventModel.create(:frequency => 10)
-          setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
+      it 'updates event frequency with new frequency' do
+        model = DatabaseEventModel.create(:frequency => 10)
+        setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
 
-          tick_at @now, :and_every_second_for => @sync_frequency - 1.second
-          @events_run.clear
-          model.update(:frequency => 30)
-          tick_at @now + @sync_frequency, :and_every_second_for => @sync_frequency - 1.seconds
+        tick_at @now, :and_every_second_for => @sync_frequency - 1.second
+        @events_run.clear
+        model.update(:frequency => 30)
+        tick_at @now + @sync_frequency, :and_every_second_for => @sync_frequency - 1.seconds
 
-          assert_equal 2, @events_run.length
-        end
+        assert_equal 2, @events_run.length
+      end
 
-        def test_event_from_database_with_edited_at_runs_at_new_at
-          model = DatabaseEventModel.create(:frequency => 1.day, :at => '10:30')
-          setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
+      it 'updates event at with new at' do
+        model = DatabaseEventModel.create(:frequency => 1.day, :at => '10:30')
+        setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
 
-          assert_will_run 'jan 1 2010 10:30:00'
-          assert_wont_run 'jan 1 2010 09:30:00'
+        assert_will_run 'jan 1 2010 10:30:00'
+        assert_wont_run 'jan 1 2010 09:30:00'
 
-          model.update(:at => '09:30')
-          tick_at @now, :and_every_second_for => @sync_frequency + 1.second
+        model.update(:at => '09:30')
+        tick_at @now, :and_every_second_for => @sync_frequency + 1.second
 
-          assert_will_run 'jan 1 2010 09:30:00'
-          assert_wont_run 'jan 1 2010 10:30:00'
-        end
+        assert_will_run 'jan 1 2010 09:30:00'
+        assert_wont_run 'jan 1 2010 10:30:00'
+      end
 
-        context "when #name is defined" do
-          def test_daily_event_from_database_with_at_should_only_run_once
-            DatabaseEventModel.create(:frequency => 1.day, :at => next_minute(@now).strftime('%H:%M'))
-            setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
+      describe "when #name is defined" do
+        it 'runs daily event with at from databse only once' do
+          DatabaseEventModel.create(:frequency => 1.day, :at => next_minute(@now).strftime('%H:%M'))
+          setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
 
-            # tick from now, though specified :at time
-            tick_at(@now, :and_every_second_for => (2 * @sync_frequency) + 1.second)
+          # tick from now, though specified :at time
+          tick_at(@now, :and_every_second_for => (2 * @sync_frequency) + 1.second)
 
-            assert_equal 1, @events_run.length
-          end
+          assert_equal 1, @events_run.length
         end
+      end
 
-        context "when #name is not defined" do
-
-          def test_daily_event_from_database_with_at_should_only_run_once
-            DatabaseEventModelWithoutName.create(:frequency => 1.day, :at => next_minute(next_minute(@now)).strftime('%H:%M'))
-            setup_sync(model: DatabaseEventModelWithoutName, :every => @sync_frequency, :events_run => @events_run)
-
-            # tick from now, though specified :at time
-            tick_at(@now, :and_every_second_for => (2 * @sync_frequency) + 1.second)
+      describe "when #name is not defined" do
+        it 'runs daily event with at from databse only once' do
+          DatabaseEventModelWithoutName.create(:frequency => 1.day, :at => next_minute(next_minute(@now)).strftime('%H:%M'))
+          setup_sync(model: DatabaseEventModelWithoutName, :every => @sync_frequency, :events_run => @events_run)
 
-            assert_equal 1, @events_run.length
-          end
+          # tick from now, though specified :at time
+          tick_at(@now, :and_every_second_for => (2 * @sync_frequency) + 1.second)
 
+          assert_equal 1, @events_run.length
         end
+      end
 
-        def test_event_from_database_with_comma_separated_at_leads_to_multiple_event_ats
-          DatabaseEventModel.create(:frequency => 1.day, :at => '16:20, 18:10')
-          setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
+      it 'creates multiple event ats with comma separated at string' do
+        DatabaseEventModel.create(:frequency => 1.day, :at => '16:20, 18:10')
+        setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
 
-          tick_at @now, :and_every_second_for => 1.second
+        tick_at @now, :and_every_second_for => 1.second
 
-          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 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
+        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
 
-        def test_syncing_multiple_database_models_works
-          DatabaseEventModel.create(:frequency => 10)
-          setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
+      it 'allows syncing multiple database models' do
+        DatabaseEventModel.create(:frequency => 10)
+        setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
 
-          DatabaseEventModel2.create(:frequency => 10)
-          setup_sync(model: DatabaseEventModel2, :every => @sync_frequency, :events_run => @events_run)
+        DatabaseEventModel2.create(:frequency => 10)
+        setup_sync(model: DatabaseEventModel2, :every => @sync_frequency, :events_run => @events_run)
 
-          tick_at(@now, :and_every_second_for => 1.second)
+        tick_at(@now, :and_every_second_for => 1.second)
 
-          assert_equal ["DatabaseEventModel:1", "DatabaseEventModel2:1"], @events_run
-        end
+        assert_equal ["DatabaseEventModel:1", "DatabaseEventModel2:1"], @events_run
       end
+    end
 
-      context "when database reload frequency is less than model frequency period" do
-        setup do
-          @events_run = []
-        end
+    describe "when database reload frequency is less than model frequency period" do
+      before do
+        @events_run = []
+      end
 
-        def test_the_event_only_runs_once_within_the_model_frequency_period
-          DatabaseEventModel.create(:frequency => 5.minutes)
-          setup_sync(model: DatabaseEventModel, :every => 1.minute, :events_run => @events_run)
+      it 'runs event only once within the model frequency period' do
+        DatabaseEventModel.create(:frequency => 5.minutes)
+        setup_sync(model: DatabaseEventModel, :every => 1.minute, :events_run => @events_run)
 
-          tick_at(@now, :and_every_second_for => 5.minutes)
+        tick_at(@now, :and_every_second_for => 5.minutes)
 
-          assert_equal 1, @events_run.length
-        end
+        assert_equal 1, @events_run.length
       end
+    end
 
-      context "with database event with :at as empty string" do
-        setup do
-          @events_run = []
+    describe "with database event :at set to empty string" do
+      before do
+        @events_run = []
 
-          DatabaseEventModel.create(:frequency => 10)
-          setup_sync(model: DatabaseEventModel, :every => 1.minute, :events_run => @events_run)
-        end
+        DatabaseEventModel.create(:frequency => 10)
+        setup_sync(model: DatabaseEventModel, :every => 1.minute, :events_run => @events_run)
+      end
 
-        def test_it_does_not_raise_an_error
-          begin
-            tick_at(Time.now, :and_every_second_for => 10.seconds)
-          rescue => e
-            assert false, "Raised an error: #{e.message}"
-          end
+      it 'does not raise an error' do
+        begin
+          tick_at(Time.now, :and_every_second_for => 10.seconds)
+        rescue => e
+          assert false, "Raised an error: #{e.message}"
         end
+      end
 
-        def test_the_event_runs
-          begin
-            tick_at(Time.now, :and_every_second_for => 10.seconds)
-          rescue => e
-          end
-          assert_equal 1, @events_run.length
+      it 'runs the event' do
+        begin
+          tick_at(Time.now, :and_every_second_for => 10.seconds)
+        rescue
         end
+        assert_equal 1, @events_run.length
       end
+    end
 
-      context "with task that respond to `tz`" do
-        setup do
-          @events_run = []
-          @utc_time_now = Time.now.utc
+    describe "with task that responds to `tz`" do
+      before do
+        @events_run = []
+        @utc_time_now = Time.now.utc
 
-          DatabaseEventModel.create(:frequency => 1.days, :at => @utc_time_now.strftime('%H:%M'), :tz => 'America/Montreal')
-          setup_sync(model: DatabaseEventModel, :every => 1.minute, :events_run => @events_run)
-        end
+        DatabaseEventModel.create(:frequency => 1.days, :at => @utc_time_now.strftime('%H:%M'), :tz => 'America/Montreal')
+        setup_sync(model: DatabaseEventModel, :every => 1.minute, :events_run => @events_run)
+      end
 
-        def test_it_does_not_raise_an_error
-          begin
-            tick_at(@utc_time_now, :and_every_second_for => 10.seconds)
-          rescue => e
-            assert false, "Raised an error: #{e.message}"
-          end
+      it 'does not raise an error' do
+        begin
+          tick_at(@utc_time_now, :and_every_second_for => 10.seconds)
+        rescue => e
+          assert false, "Raised an error: #{e.message}"
         end
+      end
 
-        def test_it_do_not_runs_the_task_as_utc
-          begin
-            tick_at(@utc_time_now, :and_every_second_for => 3.hours)
-          rescue => e
-          end
-          assert_equal 0, @events_run.length
+      it 'does not run the event based on UTC' do
+        begin
+          tick_at(@utc_time_now, :and_every_second_for => 3.hours)
+        rescue
         end
+        assert_equal 0, @events_run.length
+      end
 
-        def test_it_does_runs_the_task_as_est
-          begin
-            tick_at(@utc_time_now, :and_every_second_for => 5.hours)
-          rescue => e
-          end
-          assert_equal 1, @events_run.length
+      it 'runs the event based on America/Montreal tz' do
+        begin
+          tick_at(@utc_time_now, :and_every_second_for => 5.hours)
+        rescue
         end
+        assert_equal 1, @events_run.length
       end
     end
   end

data/test/event_test.rb

@@ -1,34 +1,34 @@
 require File.expand_path('../../lib/clockwork', __FILE__)
-require 'active_support/test_case'
+require "minitest/autorun"
 
-class EventTest < ActiveSupport::TestCase
-  describe "#thread?" do
-    setup do
-      @manager = mock
+describe Clockwork::Event do
+  describe '#thread?' do
+    before do
+      @manager = Class.new
     end
 
-    describe "manager config thread option set to true" do
-      setup do
+    describe 'manager config thread option set to true' do
+      before do
         @manager.stubs(:config).returns({ :thread => true })
       end
 
-      test "is true" do
+      it '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
+      it '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
+    describe 'manager config thread option not set' do
+      before do
         @manager.stubs(:config).returns({})
       end
 
-      test "is true if event thread option is true" do
+      it '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

data/test/manager_test.rb

@@ -1,13 +1,11 @@
 require File.expand_path('../../lib/clockwork', __FILE__)
-require 'rubygems'
-require 'test/unit'
+require "minitest/autorun"
 require 'mocha/setup'
 require 'time'
 require 'active_support/time'
-require 'active_support/test_case'
 
-class ManagerTest < ActiveSupport::TestCase
-  setup do
+describe Clockwork::Manager do
+  before do
     @manager = Clockwork::Manager.new
     class << @manager
       def log(msg); end
@@ -29,7 +27,7 @@ class ManagerTest < ActiveSupport::TestCase
     assert_equal 0, @manager.tick(t).size
   end
 
-  test "once a minute" do
+  it "once a minute" do
     @manager.every(1.minute, 'myjob')
 
     assert_will_run(t=Time.now)
@@ -37,7 +35,7 @@ class ManagerTest < ActiveSupport::TestCase
     assert_will_run(t+60)
   end
 
-  test "every three minutes" do
+  it "every three minutes" do
     @manager.every(3.minutes, 'myjob')
 
     assert_will_run(t=Time.now)
@@ -45,7 +43,7 @@ class ManagerTest < ActiveSupport::TestCase
     assert_will_run(t+3*60)
   end
 
-  test "once an hour" do
+  it "once an hour" do
     @manager.every(1.hour, 'myjob')
 
     assert_will_run(t=Time.now)
@@ -53,7 +51,7 @@ class ManagerTest < ActiveSupport::TestCase
     assert_will_run(t+60*60)
   end
 
-  test "once a week" do
+  it "once a week" do
     @manager.every(1.week, 'myjob')
 
     assert_will_run(t=Time.now)
@@ -61,7 +59,7 @@ class ManagerTest < ActiveSupport::TestCase
     assert_will_run(t+60*60*24*7)
   end
 
-  test "won't drift later and later" do
+  it "won't drift later and later" do
     @manager.every(1.hour, 'myjob')
 
     assert_will_run(Time.parse("10:00:00.5"))
@@ -69,20 +67,20 @@ class ManagerTest < ActiveSupport::TestCase
     assert_will_run(Time.parse("11:00:00.0"))
   end
 
-  test "aborts when no handler defined" do
+  it "aborts when no handler defined" do
     manager = Clockwork::Manager.new
-    assert_raise(Clockwork::Manager::NoHandlerDefined) do
+    assert_raises(Clockwork::Manager::NoHandlerDefined) do
       manager.every(1.minute, 'myjob')
     end
   end
 
-  test "aborts when fails to parse" do
-    assert_raise(Clockwork::At::FailedToParse) do
+  it "aborts when fails to parse" do
+    assert_raises(Clockwork::At::FailedToParse) do
       @manager.every(1.day, "myjob", :at => "a:bc")
     end
   end
 
-  test "general handler" do
+  it "general handler" do
     $set_me = 0
     @manager.handler { $set_me = 1 }
     @manager.every(1.minute, 'myjob')
@@ -90,7 +88,7 @@ class ManagerTest < ActiveSupport::TestCase
     assert_equal 1, $set_me
   end
 
-  test "event-specific handler" do
+  it "event-specific handler" do
     $set_me = 0
     @manager.every(1.minute, 'myjob') { $set_me = 2 }
     @manager.tick(Time.now)
@@ -98,7 +96,7 @@ class ManagerTest < ActiveSupport::TestCase
     assert_equal 2, $set_me
   end
 
-  test "should pass time to the general handler" do
+  it "should pass time to the general handler" do
     received = nil
     now = Time.now
     @manager.handler { |job, time| received = time }
@@ -107,7 +105,7 @@ class ManagerTest < ActiveSupport::TestCase
     assert_equal now, received
   end
 
-  test "should pass time to the event-specific handler" do
+  it "should pass time to the event-specific handler" do
     received = nil
     now = Time.now
     @manager.every(1.minute, 'myjob') { |job, time| received = time }
@@ -115,20 +113,18 @@ class ManagerTest < ActiveSupport::TestCase
     assert_equal now, received
   end
 
-  test "exceptions are trapped and logged" do
+  it "exceptions are trapped and logged" do
     @manager.handler { raise 'boom' }
     @manager.every(1.minute, 'myjob')
 
-    logger = Logger.new(StringIO.new)
-    @manager.configure { |c| c[:logger] = logger }
-    logger.expects(:error)
-
-    assert_nothing_raised do
-      @manager.tick(Time.now)
-    end
+    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
 
-  test "exceptions still set the last timestamp to avoid spastic error loops" do
+  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)
@@ -136,7 +132,7 @@ class ManagerTest < ActiveSupport::TestCase
     assert_equal t, event.last
   end
 
-  test "should be configurable" do
+  it "should be configurable" do
     @manager.configure do |config|
       config[:sleep_timeout] = 200
       config[:logger] = "A Logger"
@@ -150,25 +146,25 @@ class ManagerTest < ActiveSupport::TestCase
     assert_equal true, @manager.config[:thread]
   end
 
-  test "configuration should have reasonable defaults" do
+  it "configuration should have reasonable defaults" do
     assert_equal 1, @manager.config[:sleep_timeout]
     assert @manager.config[:logger].is_a?(Logger)
     assert_equal 10, @manager.config[:max_threads]
     assert_equal false, @manager.config[:thread]
   end
 
-  test "should accept unnamed job" do
+  it "should accept unnamed job" do
     event = @manager.every(1.minute)
     assert_equal 'unnamed', event.job
   end
 
-  test "should accept options without job name" do
+  it "should accept options without job name" do
     event = @manager.every(1.minute, {})
     assert_equal 'unnamed', event.job
   end
 
   describe ':at option' do
-    test "once a day at 16:20" 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'
@@ -178,7 +174,7 @@ class ManagerTest < ActiveSupport::TestCase
       assert_will_run 'jan 2 2010 16:20:00'
     end
 
-    test "twice a day at 16:20 and 18:10" do
+    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'
@@ -192,18 +188,18 @@ class ManagerTest < ActiveSupport::TestCase
   end
 
   describe ':tz option' do
-    test "time zone is not set by default" do
+    it "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
+    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
 
-    test "should be able to specify a different timezone than local for multiple times" do
+    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'
@@ -212,7 +208,7 @@ class ManagerTest < ActiveSupport::TestCase
       assert_will_run 'jan 1 2010 10:00:00 UTC'
     end
 
-    test "should be able to configure a default timezone to use for all events" do
+    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')
 
@@ -220,7 +216,7 @@ class ManagerTest < ActiveSupport::TestCase
       assert_will_run 'jan 1 2010 10:00:00 UTC'
     end
 
-    test "should be able to override a default timezone in an event" do
+    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')
 
@@ -230,19 +226,19 @@ class ManagerTest < ActiveSupport::TestCase
   end
 
   describe ':if option' do
-    test ":if true then always run" 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
 
-    test ":if false then never run" do
+    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
 
-    test ":if the first day of month" do
+    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'
@@ -250,7 +246,7 @@ class ManagerTest < ActiveSupport::TestCase
       assert_will_run 'feb 1 2010 16:20:00'
     end
 
-    test ":if it is compared to a time with zone" do
+    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|
@@ -259,15 +255,15 @@ class ManagerTest < ActiveSupport::TestCase
       assert_will_run time
     end
 
-    test ":if is not callable then raise ArgumentError" do
-      assert_raise(ArgumentError) do
+    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
-    test "should warn when an event tries to generate threads more than max_threads" do
+    it "should warn when an event tries to generate threads more than max_threads" do
       logger = Logger.new(STDOUT)
       @manager.configure do |config|
         config[:max_threads] = 1
@@ -281,7 +277,7 @@ class ManagerTest < ActiveSupport::TestCase
       @manager.tick(Time.now)
     end
 
-    test "should not warn when thread is managed by others" do
+    it "should not warn when thread is managed by others" do
       begin
         t = Thread.new { sleep 5 }
         logger = Logger.new(StringIO.new)
@@ -301,15 +297,15 @@ class ManagerTest < ActiveSupport::TestCase
   end
 
   describe "callbacks" do
-    test "should not accept unknown callback name" do
-      assert_raise(RuntimeError, "Unsupported callback unknown_callback") 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
 
-    test "should run before_tick callback once on tick" do
+    it "should run before_tick callback once on tick" do
       counter = 0
       @manager.on(:before_tick) do
         counter += 1
@@ -318,7 +314,7 @@ class ManagerTest < ActiveSupport::TestCase
       assert_equal 1, counter
     end
 
-    test "should not run events if before_tick returns false" do
+    it "should not run events if before_tick returns false" do
       @manager.on(:before_tick) do
         false
       end
@@ -326,7 +322,7 @@ class ManagerTest < ActiveSupport::TestCase
       @manager.tick
     end
 
-    test "should run before_run twice if two events are registered" do
+    it "should run before_run twice if two events are registered" do
       counter = 0
       @manager.on(:before_run) do
         counter += 1
@@ -337,7 +333,7 @@ class ManagerTest < ActiveSupport::TestCase
       assert_equal 2, counter
     end
 
-    test "should run even jobs only" do
+    it "should run even jobs only" do
       counter = 0
       ran = false
       @manager.on(:before_run) do
@@ -350,7 +346,7 @@ class ManagerTest < ActiveSupport::TestCase
       assert ran
     end
 
-    test "should run after_run callback for each event" do
+    it "should run after_run callback for each event" do
       counter = 0
       @manager.on(:after_run) do
         counter += 1
@@ -361,7 +357,7 @@ class ManagerTest < ActiveSupport::TestCase
       assert_equal 2, counter
     end
 
-    test "should run after_tick callback once" do
+    it "should run after_tick callback once" do
       counter = 0
       @manager.on(:after_tick) do
         counter += 1
@@ -372,7 +368,7 @@ class ManagerTest < ActiveSupport::TestCase
   end
 
   describe 'error_handler' do
-    setup do
+    before do
       @errors = []
       @manager.error_handler do |e|
         @errors << e
@@ -383,24 +379,24 @@ class ManagerTest < ActiveSupport::TestCase
       @manager.configure do |config|
         config[:logger] = Logger.new(@string_io)
       end
-      @manager.every(1.second, 'myjob') { raise 'test error' }
+      @manager.every(1.second, 'myjob') { raise 'it error' }
     end
 
-    test 'registered error_handler handles error from event' do
+    it 'registered error_handler handles error from event' do
       @manager.tick
-      assert_equal ['test error'], @errors.map(&:message)
+      assert_equal ['it error'], @errors.map(&:message)
     end
 
-    test 'error is notified to logger and handler' do
+    it 'error is notified to logger and handler' do
       @manager.tick
-      assert @string_io.string.include?('test error')
+      assert @string_io.string.include?('it error')
     end
 
-    test 'error in handler will NOT be suppressed' do
+    it 'error in handler will NOT be suppressed' do
       @manager.error_handler do |e|
         raise e.message + ' re-raised'
       end
-      assert_raise(RuntimeError, 'test error re-raised') do
+      assert_raises(RuntimeError, 'it error re-raised') do
         @manager.tick
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: clockwork
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.1
 platform: ruby
 authors:
 - Adam Wiggins
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-14 00:00:00.000000000 Z
+date: 2016-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tzinfo
@@ -81,34 +81,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: test-unit
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '5.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '5.8'
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
@@ -184,7 +170,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: A scheduler process to replace cron.