whenever-benlangfeld 0.9.5

data/test/functional/output_redirection_test.rb

@@ -0,0 +1,248 @@
+require 'test_helper'
+
+class OutputRedirectionTest < Whenever::TestCase
+  test "command when the output is set to nil" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      set :output, nil
+      every 2.hours do
+        command "blahblah"
+      end
+    file
+
+    assert_match(/^.+ .+ .+ .+ blahblah >> \/dev\/null 2>&1$/, output)
+  end
+
+
+  test "command when the output is set" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      set :output, 'logfile.log'
+      every 2.hours do
+        command "blahblah"
+      end
+    file
+
+    assert_match(/^.+ .+ .+ .+ blahblah >> logfile.log 2>&1$/, output)
+  end
+
+  test "command when the error and standard output is set by the command" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      every 2.hours do
+        command "blahblah", :output => {:standard => 'dev_null', :error => 'dev_err'}
+      end
+    file
+
+    assert_match(/^.+ .+ .+ .+ blahblah >> dev_null 2>> dev_err$/, output)
+  end
+
+  test "command when the output is set and the comand overrides it" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      set :output, 'logfile.log'
+      every 2.hours do
+        command "blahblah", :output => 'otherlog.log'
+      end
+    file
+
+    assert_no_match(/.+ .+ .+ .+ blahblah >> logfile.log 2>&1/, output)
+    assert_match(/^.+ .+ .+ .+ blahblah >> otherlog.log 2>&1$/, output)
+  end
+
+  test "command when the output is set and the comand overrides with standard and error" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      set :output, 'logfile.log'
+      every 2.hours do
+        command "blahblah", :output => {:error => 'dev_err', :standard => 'dev_null' }
+      end
+    file
+
+    assert_no_match(/.+ .+ .+ .+ blahblah >> logfile.log 2>&1/, output)
+    assert_match(/^.+ .+ .+ .+ blahblah >> dev_null 2>> dev_err$/, output)
+  end
+
+  test "command when the output is set and the comand rejects it" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      set :output, 'logfile.log'
+      every 2.hours do
+        command "blahblah", :output => false
+      end
+    file
+
+    assert_no_match(/.+ .+ .+ .+ blahblah >> logfile.log 2>&1/, output)
+    assert_match(/^.+ .+ .+ .+ blahblah$/, output)
+  end
+
+  test "command when the output is set and is overridden by the :set option" do
+    output = Whenever.cron :set => 'output=otherlog.log', :string => \
+    <<-file
+      set :job_template, nil
+      set :output, 'logfile.log'
+      every 2.hours do
+        command "blahblah"
+      end
+    file
+
+    assert_no_match(/.+ .+ .+ .+ blahblah >> logfile.log 2>&1/, output)
+    assert_match(/^.+ .+ .+ .+ blahblah >> otherlog.log 2>&1/, output)
+  end
+
+  test "command when the error and standard output is set" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      set :output, {:error => 'dev_err', :standard => 'dev_null' }
+      every 2.hours do
+        command "blahblah"
+      end
+    file
+
+    assert_match(/^.+ .+ .+ .+ blahblah >> dev_null 2>> dev_err$/, output)
+  end
+
+  test "command when error output is set" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      set :output, {:error => 'dev_null'}
+      every 2.hours do
+        command "blahblah"
+      end
+    file
+
+    assert_match(/^.+ .+ .+ .+ blahblah 2>> dev_null$/, output)
+  end
+
+  test "command when the standard output is set" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      set :output, {:standard => 'dev_out'}
+      every 2.hours do
+        command "blahblah"
+      end
+    file
+
+    assert_match(/^.+ .+ .+ .+ blahblah >> dev_out$/, output)
+  end
+
+  test "command when error output is set by the command" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      every 2.hours do
+        command "blahblah", :output => {:error => 'dev_err'}
+      end
+    file
+
+    assert_match(/^.+ .+ .+ .+ blahblah 2>> dev_err$/, output)
+  end
+
+  test "command when standard output is set by the command" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      every 2.hours do
+        command "blahblah", :output => {:standard => 'dev_out'}
+      end
+    file
+
+    assert_match(/^.+ .+ .+ .+ blahblah >> dev_out$/, output)
+  end
+
+  test "command when standard output is set to nil" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      every 2.hours do
+        command "blahblah", :output => {:standard => nil}
+      end
+    file
+
+    assert_match(/^.+ .+ .+ .+ blahblah > \/dev\/null$/, output)
+  end
+
+  test "command when standard error is set to nil" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      every 2.hours do
+        command "blahblah", :output => {:error => nil}
+      end
+    file
+
+    assert_match(/^.+ .+ .+ .+ blahblah 2> \/dev\/null$/, output)
+  end
+
+  test "command when standard output and standard error is set to nil" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      every 2.hours do
+        command "blahblah", :output => {:error => nil, :standard => nil}
+      end
+    file
+
+    assert_match(/^.+ .+ .+ .+ blahblah > \/dev\/null 2>&1$/, output)
+  end
+
+  test "command when standard output is set and standard error is set to nil" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      every 2.hours do
+        command "blahblah", :output => {:error => nil, :standard => 'my.log'}
+      end
+    file
+
+    assert_match(/^.+ .+ .+ .+ blahblah >> my.log 2> \/dev\/null$/, output)
+  end
+
+  test "command when standard output is nil and standard error is set" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      every 2.hours do
+        command "blahblah", :output => {:error => 'my_error.log', :standard => nil}
+      end
+    file
+
+    assert_match(/^.+ .+ .+ .+ blahblah >> \/dev\/null 2>> my_error.log$/, output)
+  end
+
+  test "command when the deprecated :cron_log is set" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      set :cron_log, "cron.log"
+      every 2.hours do
+        command "blahblah"
+      end
+    file
+
+    assert_match(/^.+ .+ .+ .+ blahblah >> cron.log 2>&1$/, output)
+  end
+
+
+  test "a command when the standard output is set to a lambda" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      set :output, lambda { "2>&1 | logger -t whenever_cron" }
+      every 2.hours do
+        command "blahblah"
+      end
+    file
+
+    assert_match(/^.+ .+ .+ .+ blahblah 2>&1 | logger -t whenever_cron$/, output)
+  end
+end

data/test/test_case.rb

@@ -0,0 +1,32 @@
+module Whenever
+  require 'minitest/autorun'
+  begin
+    # 2.0.0
+    class TestCase < MiniTest::Test; end
+  rescue NameError
+    # 1.9.3
+    class TestCase < MiniTest::Unit::TestCase; 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

@@ -0,0 +1,37 @@
+require 'whenever'
+require 'test_case'
+require 'mocha/setup'
+
+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, _ = 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, _ = 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
+
+Whenever::TestCase.send(:include, Whenever::TestHelpers)

data/test/unit/capistrano_support_test.rb

@@ -0,0 +1,147 @@
+require 'test_helper'
+require 'whenever/capistrano/v2/support'
+
+class CapistranoSupportTestSubject
+  include Whenever::CapistranoSupport
+end
+
+class CapistranoTestCase < Whenever::TestCase
+  setup do
+    @capistrano = CapistranoSupportTestSubject.new
+    configuration = mock()
+    configuration.stubs(:load).yields(@capistrano)
+    Whenever::CapistranoSupport.load_into(configuration)
+  end
+end
+
+class CapistranoSupportTest < CapistranoTestCase
+  should "return fetch(:whenever_options) from #whenever_options" do
+    @capistrano.expects(:fetch).with(:whenever_options)
+    @capistrano.whenever_options
+  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 an empty array from #whenever_roles with no defined roles" do
+    @capistrano.stubs(:whenever_options).returns({})
+    assert_equal [], @capistrano.whenever_roles
+  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])
+
+    assert_equal [:server1, :server2], @capistrano.whenever_servers
+  end
+
+  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
+
+  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
+
+  should "#whenever_run_commands: require :path arg" do
+    assert_raises ArgumentError do
+      @capistrano.whenever_run_commands(:options => {}, :command => {}, :flags => {})
+    end
+  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)
+
+    @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