whenever 0.9.2 → 0.9.3

data/test/test_case.rb

@@ -0,0 +1,39 @@
+module Whenever
+  begin
+    require 'minitest/autorun'
+    begin
+      # 2.0.0
+      class TestCase < MiniTest::Test; end
+    rescue NameError
+      # 1.9.3
+      class TestCase < MiniTest::Unit::TestCase; end
+    end
+  rescue LoadError
+    # 1.8.7
+    require 'test/unit'
+    class TestCase < Test::Unit::TestCase
+      def default_test; end
+    end
+  end
+
+  class TestCase
+    class << self
+      def setup(&block)
+        define_method(:setup) do
+          super()
+          instance_eval(&block)
+        end
+      end
+
+      def test(name, &block)
+        define_method("test_#{name}".to_sym, &block)
+      end
+      alias should test
+    end
+
+    def assert_no_match(regexp, string)
+      message = "<#{regexp}> expected to not match\n<#{string}>"
+      assert regexp !~ string, message
+    end
+  end
+end

data/test/test_helper.rb

@@ -1,18 +1,37 @@
-# Want to test the files here, in lib, not in an installed version of the gem.
-$:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
 require 'whenever'
-require 'test/unit'
-require 'shoulda'
-require 'mocha'
+require 'test_case'
+require 'mocha/setup'
 
-module TestExtensions
-  
-  def two_hours
-    "0 0,2,4,6,8,10,12,14,16,18,20,22 * * *"
-  end
-  
+module Whenever::TestHelpers
+  protected
+    def new_job(options={})
+      Whenever::Job.new(options)
+    end
+
+    def parse_time(time = nil, task = nil, at = nil)
+      Whenever::Output::Cron.new(time, task, at).time_in_cron_syntax
+    end
+
+    def two_hours
+      "0 0,2,4,6,8,10,12,14,16,18,20,22 * * *"
+    end
+
+    def assert_days_and_hours_and_minutes_equals(expected, time)
+      cron = parse_time(Whenever.seconds(2, :months), 'some task', time)
+      minutes, hours, days, *garbage = cron.split(' ')
+      assert_equal expected, [days, hours, minutes]
+    end
+
+    def assert_hours_and_minutes_equals(expected, time)
+      cron = parse_time(Whenever.seconds(2, :days), 'some task', time)
+      minutes, hours, *garbage = cron.split(' ')
+      assert_equal expected, [hours, minutes]
+    end
+
+    def assert_minutes_equals(expected, time)
+      cron = parse_time(Whenever.seconds(2, :hours), 'some task', time)
+      assert_equal expected, cron.split(' ')[0]
+    end
 end
 
-class Test::Unit::TestCase
-  include TestExtensions
-end
+Whenever::TestCase.send(:include, Whenever::TestHelpers)

data/test/unit/capistrano_support_test.rb

@@ -1,169 +1,147 @@
-require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
-require File.expand_path(File.dirname(__FILE__) + "/../../lib/whenever/capistrano/v2/support")
+require 'test_helper'
+require 'whenever/capistrano/v2/support'
 
 class CapistranoSupportTestSubject
   include Whenever::CapistranoSupport
 end
 
-class CapistranoSupportTest < Test::Unit::TestCase
-  context "when using capistrano support module" do
-    setup do
-      @capistrano = CapistranoSupportTestSubject.new
-      configuration = mock
-      configuration.stubs(:load).yields(@capistrano)
-      Whenever::CapistranoSupport.load_into(configuration)
-    end
+class CapistranoTestCase < Whenever::TestCase
+  setup do
+    @capistrano = CapistranoSupportTestSubject.new
+    configuration = mock()
+    configuration.stubs(:load).yields(@capistrano)
+    Whenever::CapistranoSupport.load_into(configuration)
+  end
+end
 
-    context "#whenever_options" do
-      should "return fetch(:whenever_options)" do
-        @capistrano.expects(:fetch).with(:whenever_options)
-        @capistrano.whenever_options
-      end
-    end
+class CapistranoSupportTest < CapistranoTestCase
+  should "return fetch(:whenever_options) from #whenever_options" do
+    @capistrano.expects(:fetch).with(:whenever_options)
+    @capistrano.whenever_options
+  end
 
-    context "#whenever_roles with one role" do
-      setup do
-        @capistrano.stubs(:whenever_options).returns({:roles => :role1})
-      end
+  should "return whenever_options[:roles] as an array from #whenever_roles with one role" do
+    @capistrano.stubs(:whenever_options).returns({:roles => :role1})
+    assert_equal [:role1], @capistrano.whenever_roles
+  end
 
-      should "return whenever_options[:roles] as an array" do
-        assert_equal [:role1], @capistrano.whenever_roles
-      end
-    end
+  should "return an empty array from #whenever_roles with no defined roles" do
+    @capistrano.stubs(:whenever_options).returns({})
+    assert_equal [], @capistrano.whenever_roles
+  end
 
-    context "#whenever_roles with no defined roles" do
-      setup do
-        @capistrano.stubs(:whenever_options).returns({})
-      end
+  should "return the list of servers returned by find_servers from #whenever_servers" do
+    @capistrano.stubs(:whenever_options).returns({})
+    @capistrano.stubs(:find_servers).returns([:server1, :server2])
 
-      should "return an empty array" do
-        assert_equal [], @capistrano.whenever_roles
-      end
-    end
+    assert_equal [:server1, :server2], @capistrano.whenever_servers
+  end
 
-    context "#whenever_servers" do
-      should "return the list of servers returned by find_servers" do
-        @capistrano.stubs(:whenever_options).returns({})
-        @capistrano.stubs(:find_servers).returns([:server1, :server2])
+  should "#whenever_prepare_for_rollback: set path to previous_release if there is a previous release" do
+    args = {}
+    @capistrano.stubs(:fetch).with(:previous_release).returns("/some/path/20121221010000")
+    assert_equal({:path => "/some/path/20121221010000"}, @capistrano.whenever_prepare_for_rollback(args))
+  end
 
-        assert_equal [:server1, :server2], @capistrano.whenever_servers
-      end
+  should "#whenever_prepare_for_rollback: set path to release_path and flags to whenever_clear_flags if there is no previous release" do
+    args = {}
+    @capistrano.stubs(:fetch).with(:previous_release).returns(nil)
+    @capistrano.stubs(:fetch).with(:release_path).returns("/some/path/20121221010000")
+    @capistrano.stubs(:fetch).with(:whenever_clear_flags).returns("--clear-crontab whenever_identifier")
+    assert_equal({:path => "/some/path/20121221010000", :flags => "--clear-crontab whenever_identifier"}, @capistrano.whenever_prepare_for_rollback(args))
+  end
+
+  should "#whenever_run_commands: require :command arg" do
+    assert_raises ArgumentError do
+      @capistrano.whenever_run_commands(:options => {}, :path => {}, :flags => {})
     end
+  end
 
-    context "#whenever_server_roles" do
-      setup do
-        @mock_servers = ["foo", "bar"]
-        @capistrano.stubs(:whenever_servers).returns(@mock_servers)
-      end
-
-      should "return a map of servers to their role(s)" do
-        @capistrano.stubs(:whenever_roles).returns([:role1, :role2])
-        @capistrano.stubs(:role_names_for_host).with("foo").returns([:role1])
-        @capistrano.stubs(:role_names_for_host).with("bar").returns([:role2])
-        assert_equal({"foo" => [:role1], "bar" => [:role2]}, @capistrano.whenever_server_roles)
-      end
-
-      should "exclude non-requested roles" do
-        @capistrano.stubs(:whenever_roles).returns([:role1, :role2])
-        @capistrano.stubs(:role_names_for_host).with("foo").returns([:role1, :role3])
-        @capistrano.stubs(:role_names_for_host).with("bar").returns([:role2])
-        assert_equal({"foo" => [:role1], "bar" => [:role2]}, @capistrano.whenever_server_roles)
-      end
-
-      should "include all roles for servers w/ >1 when they're requested" do
-        @capistrano.stubs(:whenever_roles).returns([:role1, :role2, :role3])
-        @capistrano.stubs(:role_names_for_host).with("foo").returns([:role1, :role3])
-        @capistrano.stubs(:role_names_for_host).with("bar").returns([:role2])
-        assert_equal({"foo" => [:role1, :role3], "bar" => [:role2]}, @capistrano.whenever_server_roles)
-      end
+  should "#whenever_run_commands: require :path arg" do
+    assert_raises ArgumentError do
+      @capistrano.whenever_run_commands(:options => {}, :command => {}, :flags => {})
     end
+  end
 
-    context "#whenever_prepare_for_rollback" do
-      should "set path to previous_release if there is a previous release" do
-        args = {}
-        @capistrano.stubs(:fetch).with(:previous_release).returns("/some/path/20121221010000")
-        assert_equal({:path => "/some/path/20121221010000"}, @capistrano.whenever_prepare_for_rollback(args))
-      end
-
-      should "set path to release_path and flags to whenever_clear_flags if there is no previous release" do
-        args = {}
-        @capistrano.stubs(:fetch).with(:previous_release).returns(nil)
-        @capistrano.stubs(:fetch).with(:release_path).returns("/some/path/20121221010000")
-        @capistrano.stubs(:fetch).with(:whenever_clear_flags).returns("--clear-crontab whenever_identifier")
-        assert_equal({:path => "/some/path/20121221010000", :flags => "--clear-crontab whenever_identifier"}, @capistrano.whenever_prepare_for_rollback(args))
-      end
+  should "#whenever_run_commands: require :flags arg" do
+    assert_raises ArgumentError do
+      @capistrano.whenever_run_commands(:options => {}, :path => {}, :command => {})
     end
+  end
+end
+
+class ServerRolesTest < CapistranoTestCase
+  setup do
+    @mock_servers = ["foo", "bar"]
+    @capistrano.stubs(:whenever_servers).returns(@mock_servers)
 
-    context "#whenever_run_commands" do
-      should "require :command arg" do
-        assert_raise ArgumentError do
-          @capistrano.whenever_run_commands(:options => {}, :path => {}, :flags => {})
-        end
-      end
-
-      should "require :path arg" do
-        assert_raise ArgumentError do
-          @capistrano.whenever_run_commands(:options => {}, :command => {}, :flags => {})
-        end
-      end
-
-      should "require :flags arg" do
-        assert_raise ArgumentError do
-          @capistrano.whenever_run_commands(:options => {}, :path => {}, :command => {})
-        end
-      end
-
-      context "with some servers defined" do
-        setup do
-          @mock_server1, @mock_server2, @mock_server3 = mock("Server1"), mock("Server2"), mock("Server3")
-          @mock_server1.stubs(:host).returns("server1.foo.com")
-          @mock_server2.stubs(:host).returns("server2.foo.com")
-          @mock_server3.stubs(:host => "server3.foo.com", :port => 1022, :user => 'test')
-          @mock_servers = [@mock_server1, @mock_server2]
-        end
-
-        should "call run for each host w/ appropriate role args" do
-          @capistrano.stubs(:role_names_for_host).with(@mock_server1).returns([:role1])
-          @capistrano.stubs(:role_names_for_host).with(@mock_server2).returns([:role2])
-          @capistrano.stubs(:whenever_servers).returns(@mock_servers)
-          roles = [:role1, :role2]
-          @capistrano.stubs(:whenever_options).returns({:roles => roles})
-
-          @capistrano.expects(:run).once.with('cd /foo/bar && whenever --flag1 --flag2 --roles role1', {:roles => roles, :hosts => @mock_server1})
-          @capistrano.expects(:run).once.with('cd /foo/bar && whenever --flag1 --flag2 --roles role2', {:roles => roles, :hosts => @mock_server2})
-
-          @capistrano.whenever_run_commands(:command => "whenever",
-                                            :path => "/foo/bar",
-                                            :flags => "--flag1 --flag2")
-        end
-
-        should "call run w/ all role args for servers w/ >1 role" do
-          @capistrano.stubs(:role_names_for_host).with(@mock_server1).returns([:role1, :role3])
-          @capistrano.stubs(:whenever_servers).returns([@mock_server1])
-          roles = [:role1, :role2, :role3]
-          @capistrano.stubs(:whenever_options).returns({:roles => roles})
-
-          @capistrano.expects(:run).once.with('cd /foo/bar && whenever --flag1 --flag2 --roles role1,role3', {:roles => roles, :hosts => @mock_server1})
-
-          @capistrano.whenever_run_commands(:command => "whenever",
-                                            :path => "/foo/bar",
-                                            :flags => "--flag1 --flag2")
-        end
-
-        should "call run w/ proper server options (port, user)" do
-          @capistrano.stubs(:role_names_for_host).with(@mock_server3).returns([:role3])
-          @capistrano.stubs(:whenever_servers).returns([@mock_server3])
-          @capistrano.stubs(:whenever_options).returns({:roles => [:role3]})
-
-          @capistrano.expects(:run).once.with do |command, options|
-            options[:hosts].user == "test" && options[:hosts].port == 1022
-          end
-
-          @capistrano.whenever_run_commands(:command => "whenever",
-                                            :path => "/foo/bar",
-                                            :flags => "--flag1 --flag2")
-        end
-      end
+    @mock_server1, @mock_server2, @mock_server3 = mock("Server1"), mock("Server2"), mock("Server3")
+    @mock_server1.stubs(:host).returns("server1.foo.com")
+    @mock_server2.stubs(:host).returns("server2.foo.com")
+    @mock_server3.stubs(:host => "server3.foo.com", :port => 1022, :user => 'test')
+    @mock_servers = [@mock_server1, @mock_server2]
+  end
+
+  should "return a map of servers to their role(s)" do
+    @capistrano.stubs(:whenever_roles).returns([:role1, :role2])
+    @capistrano.stubs(:role_names_for_host).with("foo").returns([:role1])
+    @capistrano.stubs(:role_names_for_host).with("bar").returns([:role2])
+    assert_equal({"foo" => [:role1], "bar" => [:role2]}, @capistrano.whenever_server_roles)
+  end
+
+  should "exclude non-requested roles" do
+    @capistrano.stubs(:whenever_roles).returns([:role1, :role2])
+    @capistrano.stubs(:role_names_for_host).with("foo").returns([:role1, :role3])
+    @capistrano.stubs(:role_names_for_host).with("bar").returns([:role2])
+    assert_equal({"foo" => [:role1], "bar" => [:role2]}, @capistrano.whenever_server_roles)
+  end
+
+  should "include all roles for servers w/ >1 when they're requested" do
+    @capistrano.stubs(:whenever_roles).returns([:role1, :role2, :role3])
+    @capistrano.stubs(:role_names_for_host).with("foo").returns([:role1, :role3])
+    @capistrano.stubs(:role_names_for_host).with("bar").returns([:role2])
+    assert_equal({"foo" => [:role1, :role3], "bar" => [:role2]}, @capistrano.whenever_server_roles)
+  end
+
+  should "call run for each host w/ appropriate role args" do
+    @capistrano.stubs(:role_names_for_host).with(@mock_server1).returns([:role1])
+    @capistrano.stubs(:role_names_for_host).with(@mock_server2).returns([:role2])
+    @capistrano.stubs(:whenever_servers).returns(@mock_servers)
+    roles = [:role1, :role2]
+    @capistrano.stubs(:whenever_options).returns({:roles => roles})
+
+    @capistrano.expects(:run).once.with('cd /foo/bar && whenever --flag1 --flag2 --roles role1', {:roles => roles, :hosts => @mock_server1})
+    @capistrano.expects(:run).once.with('cd /foo/bar && whenever --flag1 --flag2 --roles role2', {:roles => roles, :hosts => @mock_server2})
+
+    @capistrano.whenever_run_commands(:command => "whenever",
+                                      :path => "/foo/bar",
+                                      :flags => "--flag1 --flag2")
+  end
+
+  should "call run w/ all role args for servers w/ >1 role" do
+    @capistrano.stubs(:role_names_for_host).with(@mock_server1).returns([:role1, :role3])
+    @capistrano.stubs(:whenever_servers).returns([@mock_server1])
+    roles = [:role1, :role2, :role3]
+    @capistrano.stubs(:whenever_options).returns({:roles => roles})
+
+    @capistrano.expects(:run).once.with('cd /foo/bar && whenever --flag1 --flag2 --roles role1,role3', {:roles => roles, :hosts => @mock_server1})
+
+    @capistrano.whenever_run_commands(:command => "whenever",
+                                      :path => "/foo/bar",
+                                      :flags => "--flag1 --flag2")
+  end
+
+  should "call run w/ proper server options (port, user)" do
+    @capistrano.stubs(:role_names_for_host).with(@mock_server3).returns([:role3])
+    @capistrano.stubs(:whenever_servers).returns([@mock_server3])
+    @capistrano.stubs(:whenever_options).returns({:roles => [:role3]})
+
+    @capistrano.expects(:run).once.with do |command, options|
+      options[:hosts].user == "test" && options[:hosts].port == 1022
     end
+
+    @capistrano.whenever_run_commands(:command => "whenever",
+                                      :path => "/foo/bar",
+                                      :flags => "--flag1 --flag2")
   end
 end

data/test/unit/cron_test.rb

@@ -1,253 +1,226 @@
-require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+require 'test_helper'
 
-class CronTest < Test::Unit::TestCase
-
-  context "When parsing time in minutes" do
-    should "raise if less than 1 minute" do
-      assert_raises ArgumentError do
-        parse_time(59.seconds)
-      end
-
-      assert_raises ArgumentError do
-        parse_time(0.minutes)
-      end
+class CronTest < Whenever::TestCase
+  should "raise if less than 1 minute" do
+    assert_raises ArgumentError do
+      parse_time(Whenever.seconds(59, :seconds))
     end
 
-    # For santity, do some tests on straight String
-    should "parse correctly" do
-      assert_equal '* * * * *', parse_time(1.minute)
-      assert_equal '0,5,10,15,20,25,30,35,40,45,50,55 * * * *', parse_time(5.minutes)
-      assert_equal '7,14,21,28,35,42,49,56 * * * *', parse_time(7.minutes)
-      assert_equal '0,30 * * * *', parse_time(30.minutes)
-      assert_equal '32 * * * *', parse_time(32.minutes)
-      assert_not_equal '60 * * * *', parse_time(60.minutes) # 60 minutes bumps up into the hour range
-    end
-
-    # Test all minutes
-    (2..59).each do |num|
-      should "parse correctly for #{num} minutes" do
-        start = 0
-        start += num unless 60.modulo(num).zero?
-        minutes = (start..59).step(num).to_a
-
-        assert_equal "#{minutes.join(',')} * * * *", parse_time(num.minutes)
-      end
+    assert_raises ArgumentError do
+      parse_time(Whenever.seconds(0, :minutes))
     end
   end
 
-  context "When parsing time in hours" do
-    should "parse correctly" do
-      assert_equal '0 * * * *', parse_time(1.hour)
-      assert_equal '0 0,2,4,6,8,10,12,14,16,18,20,22 * * *', parse_time(2.hours)
-      assert_equal '0 0,3,6,9,12,15,18,21 * * *', parse_time(3.hours)
-      assert_equal '0 5,10,15,20 * * *', parse_time(5.hours)
-      assert_equal '0 17 * * *', parse_time(17.hours)
-      assert_not_equal '0 24 * * *', parse_time(24.hours) # 24 hours bumps up into the day range
-    end
+  # For santity, do some tests on straight String
+  should "parse correctly" do
+    assert_equal '* * * * *', parse_time(Whenever.seconds(1, :minute))
+    assert_equal '0,5,10,15,20,25,30,35,40,45,50,55 * * * *', parse_time(Whenever.seconds(5, :minutes))
+    assert_equal '7,14,21,28,35,42,49,56 * * * *', parse_time(Whenever.seconds(7, :minutes))
+    assert_equal '0,30 * * * *', parse_time(Whenever.seconds(30, :minutes))
+    assert_equal '32 * * * *', parse_time(Whenever.seconds(32, :minutes))
+    assert '60 * * * *' != parse_time(Whenever.seconds(60, :minutes)) # 60 minutes bumps up into the hour range
+  end
 
-    (2..23).each do |num|
-      should "parse correctly for #{num} hours" do
-        start = 0
-        start += num unless 24.modulo(num).zero?
-        hours = (start..23).step(num).to_a
+  # Test all minutes
+  (2..59).each do |num|
+    should "parse correctly for #{num} minutes" do
+      start = 0
+      start += num unless 60.modulo(num).zero?
+      minutes = (start..59).step(num).to_a
 
-        assert_equal "0 #{hours.join(',')} * * *", parse_time(num.hours)
-      end
+      assert_equal "#{minutes.join(',')} * * * *", parse_time(Whenever.seconds(num, :minutes))
     end
+  end
+end
+
+class CronParseHoursTest < Whenever::TestCase
+  should "parse correctly" do
+    assert_equal '0 * * * *', parse_time(Whenever.seconds(1, :hour))
+    assert_equal '0 0,2,4,6,8,10,12,14,16,18,20,22 * * *', parse_time(Whenever.seconds(2, :hours))
+    assert_equal '0 0,3,6,9,12,15,18,21 * * *', parse_time(Whenever.seconds(3, :hours))
+    assert_equal '0 5,10,15,20 * * *', parse_time(Whenever.seconds(5, :hours))
+    assert_equal '0 17 * * *', parse_time(Whenever.seconds(17, :hours))
+    assert '0 24 * * *' != parse_time(Whenever.seconds(24, :hours)) # 24 hours bumps up into the day range
+  end
 
-    should "parse correctly when given an 'at' with minutes as an Integer" do
-      assert_minutes_equals "1",  1
-      assert_minutes_equals "14", 14
-      assert_minutes_equals "27", 27
-      assert_minutes_equals "55", 55
-    end
+  (2..23).each do |num|
+    should "parse correctly for #{num} hours" do
+      start = 0
+      start += num unless 24.modulo(num).zero?
+      hours = (start..23).step(num).to_a
 
-    should "parse correctly when given an 'at' with minutes as a Time" do
-      # Basically just testing that Chronic parses some times and we get the minutes out of it
-      assert_minutes_equals "1",  '3:01am'
-      assert_minutes_equals "1",  'January 21 2:01 PM'
-      assert_minutes_equals "0",  'midnight'
-      assert_minutes_equals "59", '13:59'
+      assert_equal "0 #{hours.join(',')} * * *", parse_time(Whenever.seconds(num, :hours))
     end
   end
 
-  context "When parsing time in days (of month)" do
-    should "parse correctly" do
-      assert_equal '0 0 * * *', parse_time(1.days)
-      assert_equal '0 0 1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31 * *', parse_time(2.days)
-      assert_equal '0 0 1,5,9,13,17,21,25,29 * *', parse_time(4.days)
-      assert_equal '0 0 1,8,15,22 * *', parse_time(7.days)
-      assert_equal '0 0 1,17 * *', parse_time(16.days)
-      assert_equal '0 0 17 * *', parse_time(17.days)
-      assert_equal '0 0 29 * *', parse_time(29.days)
-      assert_not_equal '0 0 30 * *', parse_time(30.days) # 30 days bumps into the month range
-    end
-
-    should "parse correctly when given an 'at' with hours, minutes as a Time" do
-      # first param is an array with [hours, minutes]
-      assert_hours_and_minutes_equals %w(3 45),  '3:45am'
-      assert_hours_and_minutes_equals %w(20 1),  '8:01pm'
-      assert_hours_and_minutes_equals %w(0 0),   'midnight'
-      assert_hours_and_minutes_equals %w(1 23),  '1:23 AM'
-      assert_hours_and_minutes_equals %w(23 59), 'March 21 11:59 pM'
-    end
+  should "parse correctly when given an 'at' with minutes as an Integer" do
+    assert_minutes_equals "1",  1
+    assert_minutes_equals "14", 14
+    assert_minutes_equals "27", 27
+    assert_minutes_equals "55", 55
+  end
 
-    should "parse correctly when given an 'at' with hours as an Integer" do
-      # first param is an array with [hours, minutes]
-      assert_hours_and_minutes_equals %w(1 0),  1
-      assert_hours_and_minutes_equals %w(3 0),  3
-      assert_hours_and_minutes_equals %w(15 0), 15
-      assert_hours_and_minutes_equals %w(19 0), 19
-      assert_hours_and_minutes_equals %w(23 0), 23
-    end
+  should "parse correctly when given an 'at' with minutes as a Time" do
+    # Basically just testing that Chronic parses some times and we get the minutes out of it
+    assert_minutes_equals "1",  '3:01am'
+    assert_minutes_equals "1",  'January 21 2:01 PM'
+    assert_minutes_equals "0",  'midnight'
+    assert_minutes_equals "59", '13:59'
+  end
+end
+
+class CronParseDaysTest < Whenever::TestCase
+  should "parse correctly" do
+    assert_equal '0 0 * * *', parse_time(Whenever.seconds(1, :days))
+    assert_equal '0 0 1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31 * *', parse_time(Whenever.seconds(2, :days))
+    assert_equal '0 0 1,5,9,13,17,21,25,29 * *', parse_time(Whenever.seconds(4, :days))
+    assert_equal '0 0 1,8,15,22 * *', parse_time(Whenever.seconds(7, :days))
+    assert_equal '0 0 1,17 * *', parse_time(Whenever.seconds(16, :days))
+    assert_equal '0 0 17 * *', parse_time(Whenever.seconds(17, :days))
+    assert_equal '0 0 29 * *', parse_time(Whenever.seconds(29, :days))
+    assert '0 0 30 * *' != parse_time(Whenever.seconds(30, :days)) # 30 days bumps into the month range
   end
 
-  context "When parsing time in months" do
-    should "parse correctly" do
-      assert_equal '0 0 1 * *', parse_time(1.month)
-      assert_equal '0 0 1 1,3,5,7,9,11 *', parse_time(2.months)
-      assert_equal '0 0 1 1,4,7,10 *', parse_time(3.months)
-      assert_equal '0 0 1 1,5,9 *', parse_time(4.months)
-      assert_equal '0 0 1 1,6 *', parse_time(5.months)
-      assert_equal '0 0 1 7 *', parse_time(7.months)
-      assert_equal '0 0 1 8 *', parse_time(8.months)
-      assert_equal '0 0 1 9 *', parse_time(9.months)
-      assert_equal '0 0 1 10 *', parse_time(10.months)
-      assert_equal '0 0 1 11 *', parse_time(11.months)
-      assert_equal '0 0 1 12 *', parse_time(12.months)
-    end
+  should "parse correctly when given an 'at' with hours, minutes as a Time" do
+    # first param is an array with [hours, minutes]
+    assert_hours_and_minutes_equals %w(3 45),  '3:45am'
+    assert_hours_and_minutes_equals %w(20 1),  '8:01pm'
+    assert_hours_and_minutes_equals %w(0 0),   'midnight'
+    assert_hours_and_minutes_equals %w(1 23),  '1:23 AM'
+    assert_hours_and_minutes_equals %w(23 59), 'March 21 11:59 pM'
+  end
 
-    should "parse months with a date and/or time" do
-      # should set the day to 1 if no date is given
-      assert_equal '0 17 1 * *', parse_time(1.month, nil, "5pm")
-      # should use the date if one is given
-      assert_equal '0 2 23 * *', parse_time(1.month, nil, "February 23rd at 2am")
-      # should use an iteger as the day
-      assert_equal '0 0 5 * *', parse_time(1.month, nil, 5)
-    end
+  should "parse correctly when given an 'at' with hours as an Integer" do
+    # first param is an array with [hours, minutes]
+    assert_hours_and_minutes_equals %w(1 0),  1
+    assert_hours_and_minutes_equals %w(3 0),  3
+    assert_hours_and_minutes_equals %w(15 0), 15
+    assert_hours_and_minutes_equals %w(19 0), 19
+    assert_hours_and_minutes_equals %w(23 0), 23
+  end
+end
+
+class CronParseMonthsTest < Whenever::TestCase
+  should "parse correctly" do
+    assert_equal '0 0 1 * *', parse_time(Whenever.seconds(1, :month))
+    assert_equal '0 0 1 1,3,5,7,9,11 *', parse_time(Whenever.seconds(2, :months))
+    assert_equal '0 0 1 1,4,7,10 *', parse_time(Whenever.seconds(3, :months))
+    assert_equal '0 0 1 1,5,9 *', parse_time(Whenever.seconds(4, :months))
+    assert_equal '0 0 1 1,6 *', parse_time(Whenever.seconds(5, :months))
+    assert_equal '0 0 1 7 *', parse_time(Whenever.seconds(7, :months))
+    assert_equal '0 0 1 8 *', parse_time(Whenever.seconds(8, :months))
+    assert_equal '0 0 1 9 *', parse_time(Whenever.seconds(9, :months))
+    assert_equal '0 0 1 10 *', parse_time(Whenever.seconds(10, :months))
+    assert_equal '0 0 1 11 *', parse_time(Whenever.seconds(11, :months))
+    assert_equal '0 0 1 12 *', parse_time(Whenever.seconds(12, :months))
+  end
 
-    should "parse correctly when given an 'at' with days, hours, minutes as a Time" do
-      # first param is an array with [days, hours, minutes]
-      assert_days_and_hours_and_minutes_equals %w(1 3 45),  'January 1st 3:45am'
-      assert_days_and_hours_and_minutes_equals %w(11 23 0), 'Feb 11 11PM'
-      assert_days_and_hours_and_minutes_equals %w(22 1 1), 'march 22nd at 1:01 am'
-      assert_days_and_hours_and_minutes_equals %w(23 0 0), 'march 22nd at midnight' # looks like midnight means the next day
-    end
+  should "parse months with a date and/or time" do
+    # should set the day to 1 if no date is given
+    assert_equal '0 17 1 * *', parse_time(Whenever.seconds(1, :month), nil, "5pm")
+    # should use the date if one is given
+    assert_equal '0 2 23 * *', parse_time(Whenever.seconds(1, :month), nil, "February 23rd at 2am")
+    # should use an iteger as the day
+    assert_equal '0 0 5 * *', parse_time(Whenever.seconds(1, :month), nil, 5)
+  end
 
-    should "parse correctly when given an 'at' with days as an Integer" do
-      # first param is an array with [days, hours, minutes]
-      assert_days_and_hours_and_minutes_equals %w(1 0 0),  1
-      assert_days_and_hours_and_minutes_equals %w(15 0 0), 15
-      assert_days_and_hours_and_minutes_equals %w(29 0 0), 29
-    end
+  should "parse correctly when given an 'at' with days, hours, minutes as a Time" do
+    # first param is an array with [days, hours, minutes]
+    assert_days_and_hours_and_minutes_equals %w(1 3 45),  'January 1st 3:45am'
+    assert_days_and_hours_and_minutes_equals %w(11 23 0), 'Feb 11 11PM'
+    assert_days_and_hours_and_minutes_equals %w(22 1 1), 'march 22nd at 1:01 am'
+    assert_days_and_hours_and_minutes_equals %w(23 0 0), 'march 22nd at midnight' # looks like midnight means the next day
   end
 
-  context "When parsing time in days (of week)" do
-    should "parse days of the week correctly" do
-      {
-        '0' => %w(sun Sunday SUNDAY SUN),
-        '1' => %w(mon Monday MONDAY MON),
-        '2' => %w(tue tues Tuesday TUESDAY TUE),
-        '3' => %w(wed Wednesday WEDNESDAY WED),
-        '4' => %w(thu thurs thur Thursday THURSDAY THU),
-        '5' => %w(fri Friday FRIDAY FRI),
-        '6' => %w(sat Saturday SATURDAY SAT)
-      }.each do |day, day_tests|
-        day_tests.each do |day_test|
-          assert_equal "0 0 * * #{day}", parse_time(day_test)
-        end
+  should "parse correctly when given an 'at' with days as an Integer" do
+    # first param is an array with [days, hours, minutes]
+    assert_days_and_hours_and_minutes_equals %w(1 0 0),  1
+    assert_days_and_hours_and_minutes_equals %w(15 0 0), 15
+    assert_days_and_hours_and_minutes_equals %w(29 0 0), 29
+  end
+end
+
+class CronParseDaysOfWeekTest < Whenever::TestCase
+  should "parse days of the week correctly" do
+    {
+      '0' => %w(sun Sunday SUNDAY SUN),
+      '1' => %w(mon Monday MONDAY MON),
+      '2' => %w(tue tues Tuesday TUESDAY TUE),
+      '3' => %w(wed Wednesday WEDNESDAY WED),
+      '4' => %w(thu thurs thur Thursday THURSDAY THU),
+      '5' => %w(fri Friday FRIDAY FRI),
+      '6' => %w(sat Saturday SATURDAY SAT)
+    }.each do |day, day_tests|
+      day_tests.each do |day_test|
+        assert_equal "0 0 * * #{day}", parse_time(day_test)
       end
     end
+  end
 
-    should "allow additional directives" do
-      assert_equal '30 13 * * 5', parse_time('friday', nil, "1:30 pm")
-      assert_equal '22 2 * * 1', parse_time('Monday', nil, "2:22am")
-      assert_equal '55 17 * * 4', parse_time('THU', nil, "5:55PM")
-    end
+  should "allow additional directives" do
+    assert_equal '30 13 * * 5', parse_time('friday', nil, "1:30 pm")
+    assert_equal '22 2 * * 1', parse_time('Monday', nil, "2:22am")
+    assert_equal '55 17 * * 4', parse_time('THU', nil, "5:55PM")
+  end
 
-    should "parse weekday correctly" do
-      assert_equal '0 0 * * 1-5', parse_time('weekday')
-      assert_equal '0 0 * * 1-5', parse_time('Weekdays')
-      assert_equal '0 1 * * 1-5', parse_time('Weekdays', nil, "1:00 am")
-      assert_equal '59 5 * * 1-5', parse_time('Weekdays', nil, "5:59 am")
-    end
+  should "parse weekday correctly" do
+    assert_equal '0 0 * * 1-5', parse_time('weekday')
+    assert_equal '0 0 * * 1-5', parse_time('Weekdays')
+    assert_equal '0 1 * * 1-5', parse_time('Weekdays', nil, "1:00 am")
+    assert_equal '59 5 * * 1-5', parse_time('Weekdays', nil, "5:59 am")
+  end
 
-    should "parse weekend correctly" do
-      assert_equal '0 0 * * 6,0', parse_time('weekend')
-      assert_equal '0 0 * * 6,0', parse_time('Weekends')
-      assert_equal '0 7 * * 6,0', parse_time('Weekends', nil, "7am")
-      assert_equal '2 18 * * 6,0', parse_time('Weekends', nil, "6:02PM")
-    end
+  should "parse weekend correctly" do
+    assert_equal '0 0 * * 6,0', parse_time('weekend')
+    assert_equal '0 0 * * 6,0', parse_time('Weekends')
+    assert_equal '0 7 * * 6,0', parse_time('Weekends', nil, "7am")
+    assert_equal '2 18 * * 6,0', parse_time('Weekends', nil, "6:02PM")
+  end
+end
+
+class CronParseShortcutsTest < Whenever::TestCase
+  should "parse a :symbol into the correct shortcut" do
+    assert_equal '@reboot',   parse_time(:reboot)
+    assert_equal '@annually', parse_time(:annually)
+    assert_equal '@yearly',   parse_time(:yearly)
+    assert_equal '@daily',    parse_time(:daily)
+    assert_equal '@midnight', parse_time(:midnight)
+    assert_equal '@monthly',  parse_time(:monthly)
+    assert_equal '@weekly',   parse_time(:weekly)
+    assert_equal '@hourly',   parse_time(:hourly)
   end
 
-  context "When parsing time using the cron shortcuts" do
-    should "parse a :symbol into the correct shortcut" do
-      assert_equal '@reboot',   parse_time(:reboot)
-      assert_equal '@annually', parse_time(:annually)
-      assert_equal '@yearly',   parse_time(:yearly)
-      assert_equal '@daily',    parse_time(:daily)
-      assert_equal '@midnight', parse_time(:midnight)
-      assert_equal '@monthly',  parse_time(:monthly)
-      assert_equal '@weekly',   parse_time(:weekly)
-      assert_equal '@hourly',   parse_time(:hourly)
-    end
+  should "convert time-based shortcuts to times" do
+    assert_equal '0 0 1 * *',  parse_time(:month)
+    assert_equal '0 0 * * *',  parse_time(:day)
+    assert_equal '0 * * * *',  parse_time(:hour)
+    assert_equal '0 0 1 12 *', parse_time(:year)
+    assert_equal '0 0 1,8,15,22 * *', parse_time(:week)
+  end
 
-    should "convert time-based shortcuts to times" do
-      assert_equal '0 0 1 * *',  parse_time(:month)
-      assert_equal '0 0 * * *',  parse_time(:day)
-      assert_equal '0 * * * *',  parse_time(:hour)
-      assert_equal '0 0 1 12 *', parse_time(:year)
-      assert_equal '0 0 1,8,15,22 * *', parse_time(:week)
+  should "raise an exception if a valid shortcut is given but also an :at" do
+    assert_raises ArgumentError do
+      parse_time(:hourly, nil, "1:00 am")
     end
 
-    should "raise an exception if a valid shortcut is given but also an :at" do
-      assert_raises ArgumentError do
-        parse_time(:hourly, nil, "1:00 am")
-      end
-
-      assert_raises ArgumentError do
-        parse_time(:reboot, nil, 5)
-      end
-
-      assert_raises ArgumentError do
-        parse_time(:daily, nil, '4:20pm')
-      end
+    assert_raises ArgumentError do
+      parse_time(:reboot, nil, 5)
     end
-  end
 
-  context "When given raw cron sytax" do
-    should "return the same cron sytax" do
-      crons = ['0 0 27-31 * *', '* * * * *', '2/3 1,9,22 11-26 1-6 *',
-               "*\t*\t*\t*\t*",
-               '@reboot', '@yearly', '@annually', '@monthly', '@weekly',
-               '@daily', '@midnight', '@hourly']
-      crons.each do |cron|
-        assert_equal cron, parse_time(cron)
-      end
+    assert_raises ArgumentError do
+      parse_time(:daily, nil, '4:20pm')
     end
   end
+end
 
-private
-
-  def assert_days_and_hours_and_minutes_equals(expected, time)
-    cron = parse_time(2.months, 'some task', time)
-    minutes, hours, days, *garbage = cron.split(' ')
-    assert_equal expected, [days, hours, minutes]
-  end
-
-  def assert_hours_and_minutes_equals(expected, time)
-    cron = parse_time(2.days, 'some task', time)
-    minutes, hours, *garbage = cron.split(' ')
-    assert_equal expected, [hours, minutes]
-  end
-
-  def assert_minutes_equals(expected, time)
-    cron = parse_time(2.hours, 'some task', time)
-    assert_equal expected, cron.split(' ')[0]
-  end
-
-  def parse_time(time = nil, task = nil, at = nil)
-    Whenever::Output::Cron.new(time, task, at).time_in_cron_syntax
+class CronParseRawTest < Whenever::TestCase
+  should "return the same cron sytax" do
+    crons = ['0 0 27-31 * *', '* * * * *', '2/3 1,9,22 11-26 1-6 *',
+             "*\t*\t*\t*\t*",
+             '@reboot', '@yearly', '@annually', '@monthly', '@weekly',
+             '@daily', '@midnight', '@hourly']
+    crons.each do |cron|
+      assert_equal cron, parse_time(cron)
+    end
   end
-
-end
+end