whenever 0.9.7 → 0.10.0

data/test/functional/output_at_test.rb

@@ -204,4 +204,43 @@ class OutputAtTest < Whenever::TestCase
 
     assert_match '0 0 27,31 * * blahblah', output
   end
+
+  test "using custom Chronic configuration to specify time using 24 hour clock" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      set :chronic_options, :hours24 => true
+      every 1.day, :at => '03:00' do
+        command "blahblah"
+      end
+    file
+
+    assert_match '0 3 * * * blahblah', output
+  end
+
+  test "using custom Chronic configuration to specify date using little endian preference" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      set :chronic_options, :endian_precedence => :little
+      every 1.month, :at => '02/03 10:15' do
+        command "blahblah"
+      end
+    file
+
+    assert_match '15 10 2 * * blahblah', output
+  end
+
+  test "using custom Chronic configuration to specify time using 24 hour clock and date using little endian preference" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      set :chronic_options, :hours24 => true, :endian_precedence => :little
+      every 1.month, :at => '01/02 04:30' do
+        command "blahblah"
+      end
+    file
+
+    assert_match '30 4 1 * * blahblah', output
+  end
 end

data/test/functional/output_jobs_with_mailto_test.rb

@@ -0,0 +1,168 @@
+require 'test_helper'
+
+class OutputJobsWithMailtoTest < Whenever::TestCase
+  test "defined job with a mailto argument" do
+    output = Whenever.cron \
+    <<-file
+      every 2.hours do
+        command "blahblah", mailto: 'someone@example.com'
+      end
+    file
+
+    output_without_empty_line = lines_without_empty_line(output.lines)
+
+    assert_equal 'MAILTO=someone@example.com', output_without_empty_line.shift
+    assert_equal two_hours + " /bin/bash -l -c 'blahblah'", output_without_empty_line.shift
+  end
+
+  test "defined job with every method's block and a mailto argument" do
+    output = Whenever.cron \
+    <<-file
+      every 2.hours, mailto: 'someone@example.com' do
+        command "blahblah"
+      end
+    file
+
+    output_without_empty_line = lines_without_empty_line(output.lines)
+
+    assert_equal 'MAILTO=someone@example.com', output_without_empty_line.shift
+    assert_equal two_hours + " /bin/bash -l -c 'blahblah'", output_without_empty_line.shift
+  end
+
+  test "defined job which overrided mailto argument in the block" do
+    output = Whenever.cron \
+    <<-file
+      every 2.hours, mailto: 'of_the_block@example.com' do
+        command "blahblah", mailto: 'overrided_in_the_block@example.com'
+      end
+    file
+
+    output_without_empty_line = lines_without_empty_line(output.lines)
+
+    assert_equal 'MAILTO=overrided_in_the_block@example.com', output_without_empty_line.shift
+    assert_equal two_hours + " /bin/bash -l -c 'blahblah'", output_without_empty_line.shift
+  end
+
+  test "defined some jobs with various mailto argument" do
+    output = Whenever.cron \
+    <<-file
+      every 2.hours do
+        command "blahblah"
+      end
+
+      every 2.hours, mailto: 'john@example.com' do
+        command "blahblah_of_john"
+        command "blahblah2_of_john"
+      end
+
+      every 2.hours, mailto: 'sarah@example.com' do
+        command "blahblah_of_sarah"
+      end
+
+      every 2.hours do
+        command "blahblah_of_martin", mailto: 'martin@example.com'
+        command "blahblah2_of_sarah", mailto: 'sarah@example.com'
+      end
+
+      every 2.hours do
+        command "blahblah2"
+      end
+    file
+
+    output_without_empty_line = lines_without_empty_line(output.lines)
+
+    assert_equal two_hours + " /bin/bash -l -c 'blahblah'", output_without_empty_line.shift
+    assert_equal two_hours + " /bin/bash -l -c 'blahblah2'", output_without_empty_line.shift
+
+    assert_equal 'MAILTO=john@example.com', output_without_empty_line.shift
+    assert_equal two_hours + " /bin/bash -l -c 'blahblah_of_john'", output_without_empty_line.shift
+    assert_equal two_hours + " /bin/bash -l -c 'blahblah2_of_john'", output_without_empty_line.shift
+
+    assert_equal 'MAILTO=sarah@example.com', output_without_empty_line.shift
+    assert_equal two_hours + " /bin/bash -l -c 'blahblah_of_sarah'", output_without_empty_line.shift
+    assert_equal two_hours + " /bin/bash -l -c 'blahblah2_of_sarah'", output_without_empty_line.shift
+
+    assert_equal 'MAILTO=martin@example.com', output_without_empty_line.shift
+    assert_equal two_hours + " /bin/bash -l -c 'blahblah_of_martin'", output_without_empty_line.shift
+  end
+
+  test "defined some jobs with no mailto argument jobs and mailto argument jobs(no mailto jobs should be first line of cron output" do
+    output = Whenever.cron \
+    <<-file
+      every 2.hours, mailto: 'john@example.com' do
+        command "blahblah_of_john"
+        command "blahblah2_of_john"
+      end
+
+      every 2.hours do
+        command "blahblah"
+      end
+    file
+
+    output_without_empty_line = lines_without_empty_line(output.lines)
+
+    assert_equal two_hours + " /bin/bash -l -c 'blahblah'", output_without_empty_line.shift
+
+    assert_equal 'MAILTO=john@example.com', output_without_empty_line.shift
+    assert_equal two_hours + " /bin/bash -l -c 'blahblah_of_john'", output_without_empty_line.shift
+    assert_equal two_hours + " /bin/bash -l -c 'blahblah2_of_john'", output_without_empty_line.shift
+  end
+
+  test "defined some jobs with environment mailto define and various mailto argument" do
+    output = Whenever.cron \
+    <<-file
+      env 'MAILTO', 'default@example.com'
+
+      every 2.hours do
+        command "blahblah"
+      end
+
+      every 2.hours, mailto: 'sarah@example.com' do
+        command "blahblah_by_sarah"
+      end
+
+      every 2.hours do
+        command "blahblah_by_john", mailto: 'john@example.com'
+      end
+
+      every 2.hours do
+        command "blahblah2"
+      end
+    file
+
+    output_without_empty_line = lines_without_empty_line(output.lines)
+
+    assert_equal 'MAILTO=default@example.com', output_without_empty_line.shift
+    assert_equal two_hours + " /bin/bash -l -c 'blahblah'", output_without_empty_line.shift
+    assert_equal two_hours + " /bin/bash -l -c 'blahblah2'", output_without_empty_line.shift
+
+    assert_equal 'MAILTO=sarah@example.com', output_without_empty_line.shift
+    assert_equal two_hours + " /bin/bash -l -c 'blahblah_by_sarah'", output_without_empty_line.shift
+
+    assert_equal 'MAILTO=john@example.com', output_without_empty_line.shift
+    assert_equal two_hours + " /bin/bash -l -c 'blahblah_by_john'", output_without_empty_line.shift
+  end
+end
+
+class OutputJobsWithMailtoForRolesTest < Whenever::TestCase
+  test "one role requested and specified on the job with mailto argument" do
+    output = Whenever.cron roles: [:role1], :string => \
+    <<-file
+      env 'MAILTO', 'default@example.com'
+
+      every 2.hours, :roles => [:role1] do
+        command "blahblah"
+      end
+
+      every 2.hours, mailto: 'sarah@example.com', :roles => [:role2] do
+        command "blahblah_by_sarah"
+      end
+    file
+
+    output_without_empty_line = lines_without_empty_line(output.lines)
+
+    assert_equal 'MAILTO=default@example.com', output_without_empty_line.shift
+    assert_equal two_hours + " /bin/bash -l -c 'blahblah'", output_without_empty_line.shift
+    assert_nil output_without_empty_line.shift
+  end
+end

data/test/test_helper.rb

@@ -8,30 +8,40 @@ module Whenever::TestHelpers
       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
+    def parse_time(time = nil, task = nil, at = nil, options = {})
+      Whenever::Output::Cron.new(time, task, at, options).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)
+    def assert_months_and_days_and_hours_and_minutes_equals(expected, time, options = {})
+      cron = parse_time(Whenever.seconds(1, :year), 'some task', time, options)
+      minutes, hours, days, months = cron.split(' ')
+      assert_equal expected, [months, days, hours, minutes]
+    end
+
+    def assert_days_and_hours_and_minutes_equals(expected, time, options = {})
+      cron = parse_time(Whenever.seconds(2, :months), 'some task', time, options)
       minutes, hours, days, _ = 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)
+    def assert_hours_and_minutes_equals(expected, time, options = {})
+      cron = parse_time(Whenever.seconds(2, :days), 'some task', time, options)
       minutes, hours, _ = cron.split(' ')
       assert_equal expected, [hours, minutes]
     end
 
-    def assert_minutes_equals(expected, time)
-      cron = parse_time(Whenever.seconds(2, :hours), 'some task', time)
+    def assert_minutes_equals(expected, time, options = {})
+      cron = parse_time(Whenever.seconds(2, :hours), 'some task', time, options)
       assert_equal expected, cron.split(' ')[0]
     end
+
+    def lines_without_empty_line(lines)
+      lines.map { |line| line.chomp }.reject { |line| line.empty? }
+    end
 end
 
 Whenever::TestCase.send(:include, Whenever::TestHelpers)

data/test/unit/cron_test.rb

@@ -67,6 +67,26 @@ class CronParseHoursTest < Whenever::TestCase
     assert_minutes_equals "0",  'midnight'
     assert_minutes_equals "59", '13:59'
   end
+
+  should "parse correctly when given an 'at' with minutes as a Time and custom Chronic options are set" do
+    assert_minutes_equals "15", '3:15'
+    assert_minutes_equals "15", '3:15', :chronic_options => { :hours24 => true }
+    assert_minutes_equals "15", '3:15', :chronic_options => { :hours24 => false }
+
+    assert_minutes_equals "30", '6:30'
+    assert_minutes_equals "30", '6:30', :chronic_options => { :hours24 => true }
+    assert_minutes_equals "30", '6:30', :chronic_options => { :hours24 => false }
+  end
+
+  should "raise an exception when given an 'at' with an invalid minute value" do
+    assert_raises ArgumentError do
+      parse_time(Whenever.seconds(1, :hour), nil, 60)
+    end
+
+    assert_raises ArgumentError do
+      parse_time(Whenever.seconds(1, :hour), nil, -1)
+    end
+  end
 end
 
 class CronParseDaysTest < Whenever::TestCase
@@ -90,6 +110,17 @@ class CronParseDaysTest < Whenever::TestCase
     assert_hours_and_minutes_equals %w(23 59), 'March 21 11:59 pM'
   end
 
+  should "parse correctly when given an 'at' with hours, minutes as a Time and custom Chronic options are set" do
+    # first param is an array with [hours, minutes]
+    assert_hours_and_minutes_equals %w(15 15), '3:15'
+    assert_hours_and_minutes_equals %w(3 15),  '3:15', :chronic_options => { :hours24 => true }
+    assert_hours_and_minutes_equals %w(15 15), '3:15', :chronic_options => { :hours24 => false }
+
+    assert_hours_and_minutes_equals %w(6 30),  '6:30'
+    assert_hours_and_minutes_equals %w(6 30),  '6:30', :chronic_options => { :hours24 => true }
+    assert_hours_and_minutes_equals %w(6 30),  '6:30', :chronic_options => { :hours24 => false }
+  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
@@ -98,6 +129,16 @@ class CronParseDaysTest < Whenever::TestCase
     assert_hours_and_minutes_equals %w(19 0), 19
     assert_hours_and_minutes_equals %w(23 0), 23
   end
+
+  should "raise an exception when given an 'at' with an invalid hour value" do
+    assert_raises ArgumentError do
+      parse_time(Whenever.seconds(1, :day), nil, 24)
+    end
+
+    assert_raises ArgumentError do
+      parse_time(Whenever.seconds(1, :day), nil, -1)
+    end
+  end
 end
 
 class CronParseMonthsTest < Whenever::TestCase
@@ -132,12 +173,96 @@ class CronParseMonthsTest < Whenever::TestCase
     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 correctly when given an 'at' with days, hours, minutes as a Time and custom Chronic options are set" do
+    # first param is an array with [days, hours, minutes]
+    assert_days_and_hours_and_minutes_equals %w(22 15 45), 'February 22nd 3:45'
+    assert_days_and_hours_and_minutes_equals %w(22 15 45), '02/22 3:45'
+    assert_days_and_hours_and_minutes_equals %w(22 3 45),  'February 22nd 3:45', :chronic_options => { :hours24 => true }
+    assert_days_and_hours_and_minutes_equals %w(22 15 45), 'February 22nd 3:45', :chronic_options => { :hours24 => false }
+
+    assert_days_and_hours_and_minutes_equals %w(3 8 15), '02/03 8:15'
+    assert_days_and_hours_and_minutes_equals %w(3 8 15), '02/03 8:15', :chronic_options => { :endian_precedence => :middle }
+    assert_days_and_hours_and_minutes_equals %w(2 8 15), '02/03 8:15', :chronic_options => { :endian_precedence => :little }
+
+    assert_days_and_hours_and_minutes_equals %w(4 4 50),  '03/04 4:50', :chronic_options => { :endian_precedence => :middle, :hours24 => true }
+    assert_days_and_hours_and_minutes_equals %w(4 16 50), '03/04 4:50', :chronic_options => { :endian_precedence => :middle, :hours24 => false }
+    assert_days_and_hours_and_minutes_equals %w(3 4 50),  '03/04 4:50', :chronic_options => { :endian_precedence => :little, :hours24 => true }
+    assert_days_and_hours_and_minutes_equals %w(3 16 50), '03/04 4:50', :chronic_options => { :endian_precedence => :little, :hours24 => false }
+  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 "raise an exception when given an 'at' with an invalid day value" do
+    assert_raises ArgumentError do
+      parse_time(Whenever.seconds(1, :month), nil, 32)
+    end
+
+    assert_raises ArgumentError do
+      parse_time(Whenever.seconds(1, :month), nil, -1)
+    end
+  end
+end
+
+class CronParseYearTest < Whenever::TestCase
+  should "parse correctly" do
+    assert_equal '0 0 1 1 *', parse_time(Whenever.seconds(1, :year))
+  end
+
+  should "parse year with a date and/or time" do
+    # should set the day and month to 1 if no date is given
+    assert_equal '0 17 1 1 *', parse_time(Whenever.seconds(1, :year), nil, "5pm")
+    # should use the date if one is given
+    assert_equal '0 2 23 2 *', parse_time(Whenever.seconds(1, :year), nil, "February 23rd at 2am")
+    # should use an iteger as the month
+    assert_equal '0 0 1 5 *', parse_time(Whenever.seconds(1, :year), nil, 5)
+  end
+
+  should "parse correctly when given an 'at' with days, hours, minutes as a Time" do
+    # first param is an array with [months, days, hours, minutes]
+    assert_months_and_days_and_hours_and_minutes_equals %w(1 1 3 45),  'January 1st 3:45am'
+    assert_months_and_days_and_hours_and_minutes_equals %w(2 11 23 0), 'Feb 11 11PM'
+    assert_months_and_days_and_hours_and_minutes_equals %w(3 22 1 1),  'march 22nd at 1:01 am'
+    assert_months_and_days_and_hours_and_minutes_equals %w(3 23 0 0),  'march 22nd at midnight' # looks like midnight means the next day
+  end
+
+  should "parse correctly when given an 'at' with days, hours, minutes as a Time and custom Chronic options are set" do
+    # first param is an array with [months, days, hours, minutes]
+    assert_months_and_days_and_hours_and_minutes_equals %w(2 22 15 45), 'February 22nd 3:45'
+    assert_months_and_days_and_hours_and_minutes_equals %w(2 22 15 45), '02/22 3:45'
+    assert_months_and_days_and_hours_and_minutes_equals %w(2 22 3 45),  'February 22nd 3:45', :chronic_options => { :hours24 => true }
+    assert_months_and_days_and_hours_and_minutes_equals %w(2 22 15 45), 'February 22nd 3:45', :chronic_options => { :hours24 => false }
+
+    assert_months_and_days_and_hours_and_minutes_equals %w(2 3 8 15), '02/03 8:15'
+    assert_months_and_days_and_hours_and_minutes_equals %w(2 3 8 15), '02/03 8:15', :chronic_options => { :endian_precedence => :middle }
+    assert_months_and_days_and_hours_and_minutes_equals %w(3 2 8 15), '02/03 8:15', :chronic_options => { :endian_precedence => :little }
+
+    assert_months_and_days_and_hours_and_minutes_equals %w(3 4 4 50),  '03/04 4:50', :chronic_options => { :endian_precedence => :middle, :hours24 => true }
+    assert_months_and_days_and_hours_and_minutes_equals %w(3 4 16 50), '03/04 4:50', :chronic_options => { :endian_precedence => :middle, :hours24 => false }
+    assert_months_and_days_and_hours_and_minutes_equals %w(4 3 4 50),  '03/04 4:50', :chronic_options => { :endian_precedence => :little, :hours24 => true }
+    assert_months_and_days_and_hours_and_minutes_equals %w(4 3 16 50), '03/04 4:50', :chronic_options => { :endian_precedence => :little, :hours24 => false }
+  end
+
+  should "parse correctly when given an 'at' with month as an Integer" do
+    # first param is an array with [months, days, hours, minutes]
+    assert_months_and_days_and_hours_and_minutes_equals %w(1 1 0 0),  1
+    assert_months_and_days_and_hours_and_minutes_equals %w(5 1 0 0),  5
+    assert_months_and_days_and_hours_and_minutes_equals %w(12 1 0 0), 12
+  end
+
+  should "raise an exception when given an 'at' with an invalid month value" do
+    assert_raises ArgumentError do
+      parse_time(Whenever.seconds(1, :year), nil, 13)
+    end
+
+    assert_raises ArgumentError do
+      parse_time(Whenever.seconds(1, :year), nil, -1)
+    end
+  end
 end
 
 class CronParseDaysOfWeekTest < Whenever::TestCase
@@ -191,10 +316,10 @@ class CronParseShortcutsTest < Whenever::TestCase
   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 * *', parse_time(:month)
+    assert_equal '0 0 * * *', parse_time(:day)
+    assert_equal '0 * * * *', parse_time(:hour)
+    assert_equal '0 0 1 1 *', parse_time(:year)
     assert_equal '0 0 1,8,15,22 * *', parse_time(:week)
   end
 
@@ -235,6 +360,7 @@ 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 *', '*/5 6-23 * * *',
              "*\t*\t*\t*\t*",
+             '7 17 * * FRI', '7 17 * * Mon-Fri', '30 12 * Jun *', '30 12 * Jun-Aug *',
              '@reboot', '@yearly', '@annually', '@monthly', '@weekly',
              '@daily', '@midnight', '@hourly']
     crons.each do |cron|

data/test/unit/executable_test.rb

@@ -0,0 +1,142 @@
+require 'test_helper'
+
+describe 'Executable' do
+  describe 'bin/wheneverize' do
+    describe 'ARGV is not empty' do
+      describe 'file does not exist' do
+        file = '/tmp/this_does_not_exist'
+
+        it 'prints STDERR' do
+          out, err = capture_subprocess_io do
+            system('wheneverize', file)
+          end
+
+          assert_empty(out)
+          assert_match(/`#{file}' does not exist./, err)
+        end
+      end
+
+      describe 'file exists, but not a directory' do
+        file = '/tmp/this_is_a_file.txt'
+        before { FileUtils.touch(file) }
+
+        it 'prints STDERR' do
+          begin
+            out, err = capture_subprocess_io do
+              system('wheneverize', file)
+            end
+
+            assert_empty(out)
+            assert_match(/`#{file}' is not a directory./, err)
+          ensure
+            FileUtils.rm(file)
+          end
+        end
+      end
+
+      describe 'file is a directory, but another param(s) are given as well' do
+        file = '/tmp/this_is_a_directory'
+        before { FileUtils.mkdir(file) }
+
+        it 'prints STDERR' do
+          begin
+            out, err = capture_subprocess_io do
+              system('wheneverize', file, 'another', 'parameters')
+            end
+
+            assert_empty(out)
+            assert_match(/#{"Too many arguments; please specify only the " \
+                         "directory to wheneverize."}/, err)
+          ensure
+            FileUtils.rmdir(file)
+          end
+        end
+      end
+    end
+
+    describe 'ARGV is empty' do
+      dir  = '.'
+      file = 'config/schedule.rb'
+      path = File.join(dir, file)
+
+      describe 'config file already exists' do
+        before do
+          FileUtils.mkdir(File.dirname(path))
+          FileUtils.touch(path)
+        end
+
+        it 'prints STDOUT and STDERR' do
+          begin
+            out, err = capture_subprocess_io do
+              system('wheneverize')
+            end
+
+            assert_match(/\[done\] wheneverized!/, out)
+            assert_match(/\[skip\] `#{path}' already exists/, err)
+          ensure
+            FileUtils.rm_rf(File.dirname(path))
+          end
+        end
+      end
+
+      describe 'config directory does not exist' do
+        it 'prints STDOUT and STDERR' do
+          begin
+            out, err = capture_subprocess_io do
+              system('wheneverize')
+            end
+
+            assert_match(/\[add\] creating `#{File.dirname(path)}'\n/, err)
+            assert_match(/\[done\] wheneverized!/, out)
+          ensure
+            FileUtils.rm_rf(File.dirname(path))
+          end
+        end
+      end
+
+      describe 'config directory exists, but file does not' do
+        before { FileUtils.mkdir(File.dirname(path)) }
+
+        it 'writes config file and prints STDOUT' do
+          begin
+            out, err = capture_subprocess_io do
+              system('wheneverize')
+            end
+
+            assert_empty(err)
+            assert_match(
+              /\[add\] writing `#{path}'\n\[done\] wheneverized!/,
+              out
+            )
+
+            assert_match((<<-FILE
+# Use this file to easily define all of your cron jobs.
+#
+# It's helpful, but not entirely necessary to understand cron before proceeding.
+# http://en.wikipedia.org/wiki/Cron
+
+# Example:
+#
+# set :output, "/path/to/my/cron_log.log"
+#
+# every 2.hours do
+#   command "/usr/bin/some_great_command"
+#   runner "MyModel.some_method"
+#   rake "some:great:rake:task"
+# end
+#
+# every 4.days do
+#   runner "AnotherModel.prune_old_records"
+# end
+
+# Learn more: http://github.com/javan/whenever
+FILE
+                         ), IO.read(path))
+          ensure
+            FileUtils.rm_rf(File.dirname(path))
+          end
+        end
+      end
+    end
+  end
+end