whenever 0.8.2 → 1.0.0

data/test/functional/output_default_defined_jobs_test.rb

@@ -1,238 +1,296 @@
-require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+require 'test_helper'
 
-class OutputDefaultDefinedJobsTest < Test::Unit::TestCase
+class OutputDefaultDefinedJobsTest < Whenever::TestCase
 
   # command
 
-  context "A plain command with the job template set to nil" do
-    setup do
-      @output = Whenever.cron \
-      <<-file
-        set :job_template, nil
-        every 2.hours do
-          command "blahblah"
-        end
-      file
-    end
+  test "A plain command with the job template set to nil" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      every 2.hours do
+        command "blahblah"
+      end
+    file
 
-    should "output the command" do
-      assert_match /^.+ .+ .+ .+ blahblah$/, @output
-    end
+    assert_match(/^.+ .+ .+ .+ blahblah$/, output)
   end
 
-  context "A plain command with no job template set" do
-    setup do
-      @output = Whenever.cron \
-      <<-file
-        every 2.hours do
-          command "blahblah"
-        end
-      file
-    end
+  test "A plain command with no job template set" do
+    output = Whenever.cron \
+    <<-file
+      every 2.hours do
+        command "blahblah"
+      end
+    file
 
-    should "output the command with the default job template" do
-      assert_match /^.+ .+ .+ .+ \/bin\/bash -l -c 'blahblah'$/, @output
-    end
+    assert_match(/^.+ .+ .+ .+ \/bin\/bash -l -c 'blahblah'$/, output)
   end
 
-  context "A plain command that overrides the job_template set" do
-    setup do
-      @output = Whenever.cron \
-      <<-file
-        set :job_template, "/bin/bash -l -c ':job'"
-        every 2.hours do
-          command "blahblah", :job_template => "/bin/sh -l -c ':job'"
-        end
-      file
-    end
-
-    should "output the command using that job_template" do
-      assert_match /^.+ .+ .+ .+ \/bin\/sh -l -c 'blahblah'$/, @output
-      assert_no_match /bash/, @output
-    end
-  end
-
-  context "A plain command that is conditional on default environent and path" do
-    setup do
-      Whenever.expects(:path).at_least_once.returns('/what/you/want')
-      @output = Whenever.cron \
-      <<-file
-        set :job_template, nil
-        if environment == 'production' && path == '/what/you/want'
-          every 2.hours do
-            command "blahblah"
-          end
-        end
-      file
-    end
-
-    should "output the command" do
-      assert_match /blahblah/, @output
-    end
+  test "A plain command with a job_template using a normal parameter" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, "/bin/bash -l -c 'cd :path && :job'"
+      every 2.hours do
+        set :path, "/tmp"
+        command "blahblah"
+      end
+    file
+
+    assert_match(/^.+ .+ .+ .+ \/bin\/bash -l -c 'cd \/tmp \&\& blahblah'$/, output)
   end
 
-  # runner
+  test "A plain command that overrides the job_template set" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, "/bin/bash -l -c ':job'"
+      every 2.hours do
+        command "blahblah", :job_template => "/bin/sh -l -c ':job'"
+      end
+    file
 
-  context "A runner with path set" do
-    setup do
-      @output = Whenever.cron \
-      <<-file
-        set :job_template, nil
-        set :path, '/my/path'
-        every 2.hours do
-          runner 'blahblah'
-        end
-      file
-    end
 
-    should "output the runner using that path" do
-      assert_match two_hours + %( cd /my/path && script/runner -e production 'blahblah'), @output
-    end
+    assert_match(/^.+ .+ .+ .+ \/bin\/sh -l -c 'blahblah'$/, output)
+    assert_no_match(/bash/, output)
   end
 
-  context "A runner that overrides the path set" do
-    setup do
-      @output = Whenever.cron \
-      <<-file
-        set :job_template, nil
-        set :path, '/my/path'
-        every 2.hours do
-          runner "blahblah", :path => '/some/other/path'
-        end
-      file
-    end
+  test "A plain command that overrides the job_template set using a parameter" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, "/bin/bash -l -c 'cd :path && :job'"
+      every 2.hours do
+        set :path, "/tmp"
+        command "blahblah", :job_template => "/bin/sh -l -c 'cd :path && :job'"
+      end
+    file
 
-    should "output the runner using that path" do
-      assert_match two_hours + %( cd /some/other/path && script/runner -e production 'blahblah'), @output
-    end
+
+    assert_match(/^.+ .+ .+ .+ \/bin\/sh -l -c 'cd \/tmp && blahblah'$/, output)
+    assert_no_match(/bash/, output)
   end
 
-  context "A runner for a Rails 3 app" do
-    setup do
-      Whenever.expects(:path).at_least_once.returns('/my/path')
-      Whenever.expects(:rails3?).returns(true)
-      @output = Whenever.cron \
-      <<-file
-        set :job_template, nil
+  test "A plain command that is conditional on default environent and path" do
+    Whenever.expects(:path).at_least_once.returns('/what/you/want')
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      if environment == 'production' && path == '/what/you/want'
         every 2.hours do
-          runner 'blahblah'
+          command "blahblah"
         end
-      file
-    end
+      end
+    file
 
-    should "use the Rails 3 runner job by default" do
-      assert_match two_hours + %( cd /my/path && script/rails runner -e production 'blahblah'), @output
-    end
+    assert_match(/blahblah/, output)
   end
 
-  # rake
+  # runner
 
-  context "A rake command with path set" do
-    setup do
-      @output = Whenever.cron \
-      <<-file
-        set :job_template, nil
-        set :path, '/my/path'
-        every 2.hours do
-          rake "blahblah"
-        end
-      file
-    end
+  test "A runner with path set" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      set :path, '/my/path'
+      every 2.hours do
+        runner 'blahblah'
+      end
+    file
+
+    assert_match two_hours + %( cd /my/path && bundle exec script/runner -e production 'blahblah'), output
+  end
 
-    should "output the rake command using that path" do
-      assert_match two_hours + ' cd /my/path && RAILS_ENV=production bundle exec rake blahblah --silent', @output
-    end
+  test "A runner that overrides the path set" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      set :path, '/my/path'
+      every 2.hours do
+        runner "blahblah", :path => '/some/other/path'
+      end
+    file
+
+    assert_match two_hours + %( cd /some/other/path && bundle exec script/runner -e production 'blahblah'), output
   end
 
-  context "A rake for a non-bundler app" do
-    setup do
-      Whenever.expects(:path).at_least_once.returns('/my/path')
-      Whenever.expects(:bundler?).returns(false)
-      @output = Whenever.cron \
-      <<-file
-        set :job_template, nil
-        every 2.hours do
-          rake 'blahblah'
-        end
-      file
-    end
+  test "A runner for a non-bundler app" do
+    Whenever.expects(:bundler?).returns(false)
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      set :path, '/my/path'
+      every 2.hours do
+        runner 'blahblah'
+      end
+    file
+
+    assert_match two_hours + %( cd /my/path && script/runner -e production 'blahblah'), output
+  end
 
-    should "not use invoke through bundler" do
-      assert_match two_hours + ' cd /my/path && RAILS_ENV=production rake blahblah --silent', @output
-    end
+  test "A runner for an app with bin/rails" do
+    Whenever.expects(:path).at_least_once.returns('/my/path')
+    Whenever.expects(:bin_rails?).returns(true)
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      every 2.hours do
+        runner 'blahblah'
+      end
+    file
+
+    assert_match two_hours + %( cd /my/path && bin/rails runner -e production 'blahblah'), output
   end
 
-  context "A rake command that overrides the path set" do
-    setup do
-      @output = Whenever.cron \
-      <<-file
-        set :job_template, nil
-        set :path, '/my/path'
-        every 2.hours do
-          rake "blahblah", :path => '/some/other/path'
-        end
-      file
-    end
+  test "A runner for an app with script/rails" do
+    Whenever.expects(:path).at_least_once.returns('/my/path')
+    Whenever.expects(:script_rails?).returns(true)
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      every 2.hours do
+        runner 'blahblah'
+      end
+    file
+
+    assert_match two_hours + %( cd /my/path && script/rails runner -e production 'blahblah'), output
+  end
 
-    should "output the rake command using that path" do
-      assert_match two_hours + ' cd /some/other/path && RAILS_ENV=production bundle exec rake blahblah --silent', @output
-    end
+  # rake
+
+  test "A rake command with path set" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      set :path, '/my/path'
+      every 2.hours do
+        rake "blahblah"
+      end
+    file
+
+    assert_match two_hours + ' cd /my/path && RAILS_ENV=production bundle exec rake blahblah --silent', output
   end
 
+  test "A rake command with arguments" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      set :path, '/my/path'
+      every 2.hours do
+        rake "blahblah[foobar]"
+      end
+    file
+
+    assert_match two_hours + ' cd /my/path && RAILS_ENV=production bundle exec rake blahblah[foobar] --silent', output
+  end
 
-    # script
+  test "A rake for a non-bundler app" do
+    Whenever.expects(:path).at_least_once.returns('/my/path')
+    Whenever.expects(:bundler?).returns(false)
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      every 2.hours do
+        rake 'blahblah'
+      end
+    file
+
+    assert_match two_hours + ' cd /my/path && RAILS_ENV=production rake blahblah --silent', output
+  end
 
-  context "A script command with path set" do
-    setup do
-      @output = Whenever.cron \
-      <<-file
-        set :job_template, nil
-        set :path, '/my/path'
-        every 2.hours do
-          script "blahblah"
-        end
-      file
-    end
+  test "A rake command that overrides the path set" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      set :path, '/my/path'
+      every 2.hours do
+        rake "blahblah", :path => '/some/other/path'
+      end
+    file
+
+    assert_match two_hours + ' cd /some/other/path && RAILS_ENV=production bundle exec rake blahblah --silent', output
+  end
 
-    should "output the script command using that path" do
-      assert_match two_hours + ' cd /my/path && RAILS_ENV=production bundle exec script/blahblah', @output
-    end
+  test "A rake command that sets the environment variable" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      set :path, '/my/path'
+      set :environment_variable, 'RAKE_ENV'
+      every 2.hours do
+        rake "blahblah"
+      end
+    file
+
+    assert_match two_hours + ' cd /my/path && RAKE_ENV=production bundle exec rake blahblah --silent', output
   end
 
-  context "A script command for a non-bundler app" do
-    setup do
-      Whenever.expects(:path).at_least_once.returns('/my/path')
-      Whenever.expects(:bundler?).returns(false)
-      @output = Whenever.cron \
-      <<-file
-        set :job_template, nil
-        every 2.hours do
-          script 'blahblah'
-        end
-      file
-    end
+  test "A rake command that overrides the environment variable" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      set :path, '/my/path'
+      set :environment_variable, 'RAKE_ENV'
+      every 2.hours do
+        rake "blahblah", :environment_variable => 'SOME_ENV'
+      end
+    file
+
+    assert_match two_hours + ' cd /my/path && SOME_ENV=production bundle exec rake blahblah --silent', output
+  end
 
-    should "not use invoke through bundler" do
-      assert_match two_hours + ' cd /my/path && RAILS_ENV=production script/blahblah', @output
-    end
+    # script
+
+  test "A script command with path set" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      set :path, '/my/path'
+      every 2.hours do
+        script "blahblah"
+      end
+    file
+
+    assert_match two_hours + ' cd /my/path && RAILS_ENV=production bundle exec script/blahblah', output
   end
 
-  context "A script command that uses output" do
-    setup do
-      @output = Whenever.cron \
-      <<-file
-        set :job_template, nil
-        set :output, '/log/file'
-        set :path, '/my/path'
-        every 2.hours do
-          script "blahblah", :path => '/some/other/path'
-        end
-      file
-    end
+  test "A script command for a non-bundler app" do
+    Whenever.expects(:path).at_least_once.returns('/my/path')
+    Whenever.expects(:bundler?).returns(false)
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      every 2.hours do
+        script 'blahblah'
+      end
+    file
+
+    assert_match two_hours + ' cd /my/path && RAILS_ENV=production script/blahblah', output
+  end
 
-    should "output the script command using that path" do
-      assert_match two_hours + ' cd /some/other/path && RAILS_ENV=production bundle exec script/blahblah >> /log/file 2>&1', @output
-    end
+  test "A script command that uses output" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      set :output, '/log/file'
+      set :path, '/my/path'
+      every 2.hours do
+        script "blahblah", :path => '/some/other/path'
+      end
+    file
+
+    assert_match two_hours + ' cd /some/other/path && RAILS_ENV=production bundle exec script/blahblah >> /log/file 2>&1', output
   end
 
-end
+  test "A script command that uses an environment variable" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      set :environment_variable, 'RAKE_ENV'
+      set :path, '/my/path'
+      every 2.hours do
+        script "blahblah"
+      end
+    file
+
+    assert_match two_hours + ' cd /my/path && RAKE_ENV=production bundle exec script/blahblah', output
+  end
+end

data/test/functional/output_defined_job_test.rb

@@ -1,111 +1,85 @@
-require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+require 'test_helper'
 
-class OutputDefinedJobTest < Test::Unit::TestCase
+class OutputDefinedJobTest < Whenever::TestCase
+  test "defined job with a :task" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      job_type :some_job, "before :task after"
+      every 2.hours do
+        some_job "during"
+      end
+    file
 
-  context "A defined job with a :task" do
-    setup do
-      @output = Whenever.cron \
-      <<-file
-        set :job_template, nil
-        job_type :some_job, "before :task after"
-        every 2.hours do
-          some_job "during"
-        end
-      file
-    end
-
-    should "output the defined job with the task" do
-      assert_match /^.+ .+ .+ .+ before during after$/, @output
-    end
+    assert_match(/^.+ .+ .+ .+ before during after$/, output)
   end
 
-  context "A defined job with a :task and some options" do
-    setup do
-      @output = Whenever.cron \
-      <<-file
-        set :job_template, nil
-        job_type :some_job, "before :task after :option1 :option2"
-        every 2.hours do
-          some_job "during", :option1 => 'happy', :option2 => 'birthday'
-        end
-      file
-    end
+  test "defined job with a :task and some options" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      job_type :some_job, "before :task after :option1 :option2"
+      every 2.hours do
+        some_job "during", :option1 => 'happy', :option2 => 'birthday'
+      end
+    file
 
-    should "output the defined job with the task and options" do
-      assert_match /^.+ .+ .+ .+ before during after happy birthday$/, @output
-    end
+    assert_match(/^.+ .+ .+ .+ before during after happy birthday$/, output)
   end
 
-  context "A defined job with a :task and an option where the option is set globally" do
-    setup do
-      @output = Whenever.cron \
-      <<-file
-        set :job_template, nil
-        job_type :some_job, "before :task after :option1"
-        set :option1, 'happy'
-        every 2.hours do
-          some_job "during"
-        end
-      file
-    end
+  test "defined job with a :task and an option where the option is set globally" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      job_type :some_job, "before :task after :option1"
+      set :option1, 'happy'
+      every 2.hours do
+        some_job "during"
+      end
+    file
 
-    should "output the defined job with the task and options" do
-      assert_match /^.+ .+ .+ .+ before during after happy$/, @output
-    end
+    assert_match(/^.+ .+ .+ .+ before during after happy$/, output)
   end
 
-  context "A defined job with a :task and an option where the option is set globally and locally" do
-    setup do
-      @output = Whenever.cron \
-      <<-file
-        set :job_template, nil
-        job_type :some_job, "before :task after :option1"
-        set :option1, 'global'
-        every 2.hours do
-          some_job "during", :option1 => 'local'
-        end
-      file
-    end
+  test "defined job with a :task and an option where the option is set globally and locally" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      job_type :some_job, "before :task after :option1"
+      set :option1, 'global'
+      every 2.hours do
+        some_job "during", :option1 => 'local'
+      end
+    file
 
-    should "output the defined job using the local option" do
-      assert_match /^.+ .+ .+ .+ before during after local$/, @output
-    end
+    assert_match(/^.+ .+ .+ .+ before during after local$/, output)
   end
 
-  context "A defined job with a :task and an option that is not set" do
-    setup do
-      @output = Whenever.cron \
-      <<-file
-        set :job_template, nil
-        job_type :some_job, "before :task after :option1"
-        every 2.hours do
-          some_job "during", :option2 => 'happy'
-        end
-      file
-    end
+  test "defined job with a :task and an option that is not set" do
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      job_type :some_job, "before :task after :option1"
+      every 2.hours do
+        some_job "during", :option2 => 'happy'
+      end
+    file
 
-    should "output the defined job with that option left untouched" do
-      assert_match /^.+ .+ .+ .+ before during after :option1$/, @output
-    end
+    assert_match(/^.+ .+ .+ .+ before during after :option1$/, output)
   end
 
-  context "A defined job that uses a :path where none is explicitly set" do
-    setup do
-      Whenever.stubs(:path).returns('/my/path')
+  test "defined job that uses a :path where none is explicitly set" do
+    Whenever.stubs(:path).returns('/my/path')
 
-      @output = Whenever.cron \
-      <<-file
-        set :job_template, nil
-        job_type :some_job, "cd :path && :task"
-        every 2.hours do
-          some_job 'blahblah'
-        end
-      file
-    end
+    output = Whenever.cron \
+    <<-file
+      set :job_template, nil
+      job_type :some_job, "cd :path && :task"
+      every 2.hours do
+        some_job 'blahblah'
+      end
+    file
 
-    should "default to using the Whenever.path" do
-      assert_match two_hours + %( cd /my/path && blahblah), @output
-    end
+    assert_match two_hours + %( cd /my/path && blahblah), output
   end
-
 end