rake 0.8.7 → 0.9.2

data/test/{test_task_arguments.rb → test_rake_task_arguments.rb}

@@ -1,10 +1,7 @@
-#!/usr/bin/env ruby
-
-require 'test/unit'
-require 'rake'
+require File.expand_path('../helper', __FILE__)
 
 ######################################################################
-class TestTaskArguments < Test::Unit::TestCase
+class TestRakeTaskArguments < Rake::TestCase
   def teardown
     ENV.delete('rev')
     ENV.delete('VER')
@@ -50,12 +47,12 @@ class TestTaskArguments < Test::Unit::TestCase
     assert_nil ta.cc
   end
 
-  def test_args_can_reference_env_values
+  def test_args_do_not_reference_env_values
     ta = Rake::TaskArguments.new(["aa"], [1])
     ENV['rev'] = "1.2"
     ENV['VER'] = "2.3"
-    assert_equal "1.2", ta.rev
-    assert_equal "2.3", ta.ver
+    assert_nil ta.rev
+    assert_nil ta.ver
   end
 
   def test_creating_new_argument_scopes
@@ -73,7 +70,7 @@ class TestTaskArguments < Test::Unit::TestCase
     child = Rake::TaskArguments.new(['aa'], [2], parent)
     assert_equal 2, child.aa
   end
-  
+
   def test_default_arguments_values_can_be_merged
     ta = Rake::TaskArguments.new(["aa", "bb"], [nil, "original_val"])
     ta.with_defaults({ :aa => 'default_val' })
@@ -81,7 +78,7 @@ class TestTaskArguments < Test::Unit::TestCase
     assert_equal 'original_val', ta[:bb]
   end
 
-  def test_default_arguements_that_dont_match_names_are_ignored
+  def test_default_arguments_that_dont_match_names_are_ignored
     ta = Rake::TaskArguments.new(["aa", "bb"], [nil, "original_val"])
     ta.with_defaults({ "cc" => "default_val" })
     assert_nil ta[:cc]

data/test/{test_tasklib.rb → test_rake_task_lib.rb}

@@ -1,10 +1,7 @@
-#!/usr/bin/env ruby
-
-require 'test/unit'
+require File.expand_path('../helper', __FILE__)
 require 'rake/tasklib'
 
-
-class TestTaskLib < Test::Unit::TestCase
+class TestRakeTaskLib < Rake::TestCase
   def test_paste
     tl = Rake::TaskLib.new
     assert_equal :ab, tl.paste(:a, :b)

data/test/{test_task_manager.rb → test_rake_task_manager.rb}

@@ -1,22 +1,15 @@
-#!/usr/bin/env ruby
+require File.expand_path('../helper', __FILE__)
 
-require 'test/unit'
-require 'rake'
-require 'test/rake_test_setup'
-
-class TaskManager
-  include Rake::TaskManager
-end
-
-class TestTaskManager < Test::Unit::TestCase
-  include TestMethods
+class TestRakeTaskManager < Rake::TestCase
 
   def setup
-    @tm = TaskManager.new
+    super
+
+    @tm = Rake::TestCase::TaskManager.new
   end
 
   def test_create_task_manager
-    assert_not_nil @tm
+    refute_nil @tm
     assert_equal [], @tm.tasks
   end
 
@@ -65,14 +58,14 @@ class TestTaskManager < Test::Unit::TestCase
   end
 
   def test_name_lookup_with_implicit_file_tasks
-    t = @tm["README"]
-    assert_equal "README", t.name
+    t = @tm["README.rdoc"]
+    assert_equal "README.rdoc", t.name
     assert Rake::FileTask === t
   end
 
   def test_name_lookup_with_nonexistent_task
-    assert_exception(RuntimeError) {
-      t = @tm["DOES NOT EXIST"]
+    assert_raises(RuntimeError) {
+      @tm["DOES NOT EXIST"]
     }
   end
 
@@ -129,7 +122,7 @@ class TestTaskManager < Test::Unit::TestCase
       end
     end
     assert_equal t1, @tm[:t, []]
-    assert_equal t2, @tm[:t, ["a"]]    
+    assert_equal t2, @tm[:t, ["a"]]
     assert_equal t3, @tm[:t, ["a", "b"]]
     assert_equal s,  @tm[:s, ["a", "b"]]
     assert_equal s,  @tm[:s, ["a"]]
@@ -147,27 +140,6 @@ class TestTaskManager < Test::Unit::TestCase
     @tm["a:x"].invoke
     assert_equal ["next z"], values
   end
-  
-end
-
-class TestTaskManagerArgumentResolution < Test::Unit::TestCase
-  def test_good_arg_patterns
-    assert_equal [:t, [], []],       task(:t)
-    assert_equal [:t, [], [:x]],     task(:t => :x)
-    assert_equal [:t, [], [:x, :y]], task(:t => [:x, :y])
 
-    assert_equal [:t, [:a, :b], []],       task(:t, :a, :b)
-    assert_equal [:t, [], [:x]],           task(:t, :needs => :x)
-    assert_equal [:t, [:a, :b], [:x]],     task(:t, :a, :b, :needs => :x)
-    assert_equal [:t, [:a, :b], [:x, :y]], task(:t, :a, :b, :needs => [:x, :y])
-
-    assert_equal [:t, [:a, :b], []],       task(:t, [:a, :b])
-    assert_equal [:t, [:a, :b], [:x]],     task(:t, [:a, :b] => :x)
-    assert_equal [:t, [:a, :b], [:x, :y]], task(:t, [:a, :b] => [:x, :y])
-  end
-
-  def task(*args)
-    tm = TaskManager.new
-    tm.resolve_args(args)
-  end
 end
+

data/test/test_rake_task_manager_argument_resolution.rb

@@ -0,0 +1,36 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestRakeTaskManagerArgumentResolution < Rake::TestCase
+
+  def setup
+    super
+
+    Rake.application.options.ignore_deprecate = true
+  end
+
+  def teardown
+    Rake.application.options.ignore_deprecate = false
+
+    super
+  end
+
+  def test_good_arg_patterns
+    assert_equal [:t, [], []],       task(:t)
+    assert_equal [:t, [], [:x]],     task(:t => :x)
+    assert_equal [:t, [], [:x, :y]], task(:t => [:x, :y])
+
+    assert_equal [:t, [:a, :b], []],       task(:t, :a, :b)
+    assert_equal [:t, [], [:x]],           task(:t, :needs => :x)
+    assert_equal [:t, [:a, :b], [:x]],     task(:t, :a, :b, :needs => :x)
+    assert_equal [:t, [:a, :b], [:x, :y]], task(:t, :a, :b, :needs => [:x, :y])
+
+    assert_equal [:t, [:a, :b], []],       task(:t, [:a, :b])
+    assert_equal [:t, [:a, :b], [:x]],     task(:t, [:a, :b] => :x)
+    assert_equal [:t, [:a, :b], [:x, :y]], task(:t, [:a, :b] => [:x, :y])
+  end
+
+  def task(*args)
+    tm = Rake::TestCase::TaskManager.new
+    tm.resolve_args(args)
+  end
+end

data/test/test_rake_task_with_arguments.rb

@@ -0,0 +1,162 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestRakeTaskWithArguments < Rake::TestCase
+  include Rake
+
+  def setup
+    super
+
+    Task.clear
+    Rake::TaskManager.record_task_metadata = true
+  end
+
+  def teardown
+    Rake::TaskManager.record_task_metadata = false
+
+    super
+  end
+
+  def test_no_args_given
+    t = task :t
+    assert_equal [], t.arg_names
+  end
+
+  def test_args_given
+    t = task :t, :a, :b
+    assert_equal [:a, :b], t.arg_names
+  end
+
+  def test_name_and_needs
+    t = task(:t => [:pre])
+    assert_equal "t", t.name
+    assert_equal [], t.arg_names
+    assert_equal ["pre"], t.prerequisites
+  end
+
+  def test_name_args_and_explicit_needs
+    ignore_deprecations do
+      t = task(:t, :x, :y, :needs => [:pre])
+      assert_equal "t", t.name
+      assert_equal [:x, :y], t.arg_names
+      assert_equal ["pre"], t.prerequisites
+    end
+  end
+
+  def test_illegal_keys_in_task_name_hash
+    ignore_deprecations do
+      assert_raises RuntimeError do
+        t = task(:t, :x, :y => 1, :needs => [:pre])
+      end
+    end
+  end
+
+  def test_arg_list_is_empty_if_no_args_given
+    t = task(:t) { |tt, args| assert_equal({}, args.to_hash) }
+    t.invoke(1, 2, 3)
+  end
+
+  def test_tasks_can_access_arguments_as_hash
+    t = task :t, :a, :b, :c do |tt, args|
+      assert_equal({:a => 1, :b => 2, :c => 3}, args.to_hash)
+      assert_equal 1, args[:a]
+      assert_equal 2, args[:b]
+      assert_equal 3, args[:c]
+      assert_equal 1, args.a
+      assert_equal 2, args.b
+      assert_equal 3, args.c
+    end
+    t.invoke(1, 2, 3)
+  end
+
+  def test_actions_of_various_arity_are_ok_with_args
+    notes = []
+    t = task(:t, :x) do
+      notes << :a
+    end
+    t.enhance do | |
+      notes << :b
+    end
+    t.enhance do |task|
+      notes << :c
+      assert_kind_of Task, task
+    end
+    t.enhance do |t2, args|
+      notes << :d
+      assert_equal t, t2
+      assert_equal({:x => 1}, args.to_hash)
+    end
+    t.invoke(1)
+    assert_equal [:a, :b, :c, :d], notes
+  end
+
+  def test_arguments_are_passed_to_block
+    t = task(:t, :a, :b) { |tt, args|
+      assert_equal( { :a => 1, :b => 2 }, args.to_hash )
+    }
+    t.invoke(1, 2)
+  end
+
+  def test_extra_parameters_are_ignored
+    t = task(:t, :a) { |tt, args|
+      assert_equal 1, args.a
+      assert_nil args.b
+    }
+    t.invoke(1, 2)
+  end
+
+  def test_arguments_are_passed_to_all_blocks
+    counter = 0
+    t = task :t, :a
+    task :t do |tt, args|
+      assert_equal 1, args.a
+      counter += 1
+    end
+    task :t do |tt, args|
+      assert_equal 1, args.a
+      counter += 1
+    end
+    t.invoke(1)
+    assert_equal 2, counter
+  end
+
+  def test_block_with_no_parameters_is_ok
+    t = task(:t) { }
+    t.invoke(1, 2)
+  end
+
+  def test_name_with_args
+    desc "T"
+    t = task(:tt, :a, :b)
+    assert_equal "tt", t.name
+    assert_equal "T", t.comment
+    assert_equal "[a,b]", t.arg_description
+    assert_equal "tt[a,b]", t.name_with_args
+    assert_equal [:a, :b],t.arg_names
+  end
+
+  def test_named_args_are_passed_to_prereqs
+    value = nil
+    pre = task(:pre, :rev) { |t, args| value = args.rev }
+    t = task(:t, [:name, :rev] => [:pre])
+    t.invoke("bill", "1.2")
+    assert_equal "1.2", value
+  end
+
+  def test_args_not_passed_if_no_prereq_names
+    pre = task(:pre) { |t, args|
+      assert_equal({}, args.to_hash)
+      assert_equal "bill", args.name
+    }
+    t = task(:t, [:name, :rev] => [:pre])
+    t.invoke("bill", "1.2")
+  end
+
+  def test_args_not_passed_if_no_arg_names
+    pre = task(:pre, :rev) { |t, args|
+      assert_equal({}, args.to_hash)
+    }
+    t = task(:t  => [:pre])
+    t.invoke("bill", "1.2")
+  end
+end
+

data/test/test_rake_test_task.rb

@@ -0,0 +1,122 @@
+require File.expand_path('../helper', __FILE__)
+require 'rake/testtask'
+
+class TestRakeTestTask < Rake::TestCase
+  include Rake
+
+  def setup
+    super
+
+    Task.clear
+    ENV.delete('TEST')
+  end
+
+  def teardown
+    FileUtils.rm_rf("testdata")
+
+    super
+  end
+
+  def test_no_task
+    assert ! Task.task_defined?(:test)
+  end
+
+  def test_defaults
+    tt = Rake::TestTask.new do |t| end
+    refute_nil tt
+    assert_equal :test, tt.name
+    assert_equal ['lib'], tt.libs
+    assert_equal 'test/test*.rb', tt.pattern
+    assert_equal false, tt.verbose
+    assert Task.task_defined?(:test)
+  end
+
+  def test_non_defaults
+    tt = Rake::TestTask.new(:example) do |t|
+      t.libs = ['src', 'ext']
+      t.pattern = 'test/tc_*.rb'
+      t.verbose = true
+    end
+    refute_nil tt
+    assert_equal :example, tt.name
+    assert_equal ['src', 'ext'], tt.libs
+    assert_equal 'test/tc_*.rb', tt.pattern
+    assert_equal true, tt.verbose
+    assert Task.task_defined?(:example)
+  end
+
+  def test_pattern
+    tt = Rake::TestTask.new do |t|
+      t.pattern = '*.rb'
+    end
+    assert_equal ['*.rb'], tt.file_list.to_a
+  end
+
+  def test_env_test
+    ENV['TEST'] = 'testfile.rb'
+    tt = Rake::TestTask.new do |t|
+      t.pattern = '*'
+    end
+    assert_equal ["testfile.rb"], tt.file_list.to_a
+  end
+
+  def test_test_files
+    tt = Rake::TestTask.new do |t|
+      t.test_files = FileList['a.rb', 'b.rb']
+    end
+    assert_equal ["a.rb", 'b.rb'], tt.file_list.to_a
+  end
+
+  def test_both_pattern_and_test_files
+    tt = Rake::TestTask.new do |t|
+      t.test_files = FileList['a.rb', 'b.rb']
+      t.pattern = '*.rb'
+    end
+    assert_equal ['a.rb', 'b.rb', '*.rb'], tt.file_list.to_a
+  end
+
+  def test_direct_run_has_quoted_paths
+    test_task = Rake::TestTask.new(:tx) do |t|
+      t.loader = :direct
+    end
+    assert_match(/-e ".*"/, test_task.run_code)
+  end
+
+  def test_testrb_run_has_quoted_paths_on_ruby_182
+    test_task = Rake::TestTask.new(:tx) do |t|
+      t.loader = :testrb
+    end
+    flexmock(test_task).should_receive(:ruby_version).and_return('1.8.2')
+    assert_match(/^-S testrb +".*"$/, test_task.run_code)
+  end
+
+  def test_testrb_run_has_quoted_paths_on_ruby_186
+    test_task = Rake::TestTask.new(:tx) do |t|
+      t.loader = :testrb
+    end
+    flexmock(test_task).should_receive(:ruby_version).and_return('1.8.6')
+    assert_match(/^-S testrb +$/, test_task.run_code)
+  end
+
+  def test_rake_run_has_quoted_paths
+    test_task = Rake::TestTask.new(:tx) do |t|
+      t.loader = :rake
+    end
+    assert_match(/".*"/, test_task.run_code)
+  end
+
+  def test_nested_libs_will_be_flattened
+    test_task = Rake::TestTask.new(:tx) do |t|
+      t.libs << ["A", "B"]
+    end
+    sep = File::PATH_SEPARATOR
+    assert_match(/lib#{sep}A#{sep}B/, test_task.ruby_opts_string)
+  end
+
+  def test_empty_lib_path_implies_no_dash_I_option
+    test_task = Rake::TestTask.new(:tx) do |t|
+      t.libs = []
+    end
+    refute_match(/-I/, test_task.ruby_opts_string)
+  end
+end

data/test/{test_top_level_functions.rb → test_rake_top_level_functions.rb}

@@ -1,29 +1,19 @@
-#!/usr/bin/env ruby
+require File.expand_path('../helper', __FILE__)
 
-begin
-  require 'rubygems'
-rescue LoadError
-  # got no gems
-end
-
-require 'test/unit'
-require 'flexmock/test_unit'
-require 'test/capture_stdout'
-require 'test/rake_test_setup'
-require 'rake'
-
-class TestTopLevelFunctions < Test::Unit::TestCase
-  include CaptureStdout
-  include TestMethods
+class TestRakeTopLevelFunctions < Rake::TestCase
 
   def setup
     super
+
     @app = Rake.application
     Rake.application = flexmock("app")
+    Rake.application.should_receive(:deprecate).
+      and_return { |old, new, call| @app.deprecate(old, new, call) }
   end
 
   def teardown
     Rake.application = @app
+
     super
   end
 
@@ -40,7 +30,7 @@ class TestTopLevelFunctions < Test::Unit::TestCase
   end
 
   def test_when_writing
-    out = capture_stdout do
+    out, = capture_io do
       when_writing("NOTWRITING") do
         puts "WRITING"
       end
@@ -49,15 +39,15 @@ class TestTopLevelFunctions < Test::Unit::TestCase
   end
 
   def test_when_not_writing
-    RakeFileUtils.nowrite_flag = true
-    out = capture_stdout do
+    Rake::FileUtilsExt.nowrite_flag = true
+    _, err = capture_io do
       when_writing("NOTWRITING") do
         puts "WRITING"
       end
     end
-    assert_equal "DRYRUN: NOTWRITING\n", out
+    assert_equal "DRYRUN: NOTWRITING\n", err
   ensure
-    RakeFileUtils.nowrite_flag = false
+    Rake::FileUtilsExt.nowrite_flag = false
   end
 
   def test_missing_constants_task
@@ -81,6 +71,6 @@ class TestTopLevelFunctions < Test::Unit::TestCase
   end
 
   def test_missing_other_constant
-    assert_exception(NameError) do Object.const_missing(:Xyz) end
+    assert_raises(NameError) do Object.const_missing(:Xyz) end
   end
 end

data/test/{test_win32.rb → test_rake_win32.rb}

@@ -1,14 +1,7 @@
-#!/usr/bin/env ruby
+require File.expand_path('../helper', __FILE__)
 
-require 'test/unit'
-require 'test/rake_test_setup'
-require 'test/in_environment'
-
-require 'rake'
-
-class TestWin32 < Test::Unit::TestCase
+class TestRakeWin32 < Rake::TestCase
   include InEnvironment
-  include TestMethods
 
   Win32 = Rake::Win32
 
@@ -63,10 +56,28 @@ class TestWin32 < Test::Unit::TestCase
       'APPDATA' => nil,
       "USERPROFILE" => nil
       ) do
-      assert_exception(Rake::Win32::Win32HomeError) do
+      assert_raises(Rake::Win32::Win32HomeError) do
         Win32.win32_system_dir
       end
     end
   end
 
+  def test_win32_backtrace_with_different_case
+    ex = nil
+    begin
+     raise 'test exception'
+    rescue => ex
+    end
+
+    ex.set_backtrace ['abc', 'rakefile']
+
+    rake = Rake::Application.new
+    rake.options.trace = true
+    rake.instance_variable_set(:@rakefile, 'Rakefile')
+
+    _, err = capture_io { rake.display_error_message(ex) }
+
+    assert_match(/rakefile/, err)
+  end
+
 end

data/test/test_sys.rb

@@ -0,0 +1,20 @@
+require File.expand_path('../helper', __FILE__)
+begin
+  old_verbose = $VERBOSE
+  $VERBOSE = nil
+  require 'rake/contrib/sys'
+ensure
+  $VERBOSE = old_verbose
+end
+
+class TestSys < Rake::TestCase
+
+  def test_split_all
+    assert_equal ['a'], Sys.split_all('a')
+    assert_equal ['..'], Sys.split_all('..')
+    assert_equal ['/'], Sys.split_all('/')
+    assert_equal ['a', 'b'], Sys.split_all('a/b')
+    assert_equal ['/', 'a', 'b'], Sys.split_all('/a/b')
+    assert_equal ['..', 'a', 'b'], Sys.split_all('../a/b')
+  end
+end