rake 0.9.0 → 0.9.1

data/test/test_rake_invocation_chain.rb

@@ -0,0 +1,52 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestRakeInvocationChain < Rake::TestCase
+
+  def setup
+    super
+
+    @empty = Rake::InvocationChain::EMPTY
+
+    @first_member = "A"
+    @second_member = "B"
+    @one = @empty.append(@first_member)
+    @two = @one.append(@second_member)
+  end
+
+  def test_append
+    chain = @empty.append("A")
+
+    assert_equal 'TOP => A', chain.to_s # HACK
+  end
+
+  def test_append_one_circular
+    ex = assert_raises RuntimeError do
+      @one.append(@first_member)
+    end
+    assert_match(/circular +dependency/i, ex.message)
+    assert_match(/A.*=>.*A/, ex.message)
+  end
+
+  def test_append_two_circular
+    ex = assert_raises RuntimeError do
+      @two.append(@first_member)
+    end
+    assert_match(/A.*=>.*B.*=>.*A/, ex.message)
+  end
+
+  def test_member_eh_one
+    assert @one.member?(@first_member)
+  end
+
+  def test_member_eh_two
+    assert @two.member?(@first_member)
+    assert @two.member?(@second_member)
+  end
+
+  def test_to_s_empty
+    assert_equal "TOP", @empty.to_s
+    assert_equal "TOP => A", @one.to_s
+  end
+
+end
+

data/test/{lib/makefile_loader_test.rb → test_rake_makefile_loader.rb}

@@ -1,10 +1,7 @@
-#!/usr/bin/env ruby
-
-require 'test/unit'
-require 'rake'
+require File.expand_path('../helper', __FILE__)
 require 'rake/loaders/makefile'
 
-class TestMakefileLoader < Test::Unit::TestCase
+class TestRakeMakefileLoader < Rake::TestCase
   include Rake
 
   def test_parse

data/test/{lib/multitask_test.rb → test_rake_multi_task.rb}

@@ -1,14 +1,13 @@
-#!/usr/bin/env ruby
-
-require 'test/unit'
+require File.expand_path('../helper', __FILE__)
 require 'thread'
-require 'rake'
 
-######################################################################
-class TestMultiTask < Test::Unit::TestCase
+class TestRakeMultiTask < Rake::TestCase
   include Rake
+  include Rake::DSL
 
   def setup
+    super
+
     Task.clear
     @runs = Array.new
     @mutex = Mutex.new
@@ -50,4 +49,3 @@ class TestMultiTask < Test::Unit::TestCase
   end
 end
 
-

data/test/{lib/namespace_test.rb → test_rake_name_space.rb}

@@ -1,18 +1,6 @@
-#!/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 'rake'
-require 'test/rake_test_setup'
-
-class TestNameSpace < Test::Unit::TestCase
-  include TestMethods
+class TestRakeNameSpace < Rake::TestCase
 
   class TM
     include Rake::TaskManager
@@ -21,7 +9,7 @@ class TestNameSpace < Test::Unit::TestCase
   def test_namespace_creation
     mgr = TM.new
     ns = Rake::NameSpace.new(mgr, [])
-    assert_not_nil ns
+    refute_nil ns
   end
 
   def test_namespace_lookup
@@ -30,7 +18,7 @@ class TestNameSpace < Test::Unit::TestCase
       mgr.define_task(Rake::Task, "t")
     end
 
-    assert_not_nil ns["t"]
+    refute_nil ns["t"]
     assert_equal mgr["n:t"], ns["t"]
   end
 

data/test/{lib/package_task_test.rb → test_rake_package_task.rb}

@@ -1,11 +1,7 @@
-#!/usr/bin/env ruby
-
-require 'test/unit'
+require File.expand_path('../helper', __FILE__)
 require 'rake/packagetask'
-require 'test/rake_test_setup'
 
-class TestPackageTask < Test::Unit::TestCase
-  include TestMethods
+class TestRakePackageTask < Rake::TestCase
 
   def test_initialize
     pkg = Rake::PackageTask.new("pkgr", "1.2.3") { |p|

data/test/{lib/pathmap_test.rb → test_rake_path_map.rb}

@@ -1,12 +1,6 @@
-#!/usr/bin/env ruby
+require File.expand_path('../helper', __FILE__)
 
-require 'test/unit'
-require 'test/rake_test_setup'
-require 'rake'
-
-# ====================================================================
-class TestPathMap < Test::Unit::TestCase
-  include TestMethods
+class TestRakePathMap < Rake::TestCase
 
   def test_returns_self_with_no_args
     assert_equal "abc.rb", "abc.rb".pathmap
@@ -88,7 +82,7 @@ class TestPathMap < Test::Unit::TestCase
   end
 
   def test_undefined_percent_causes_error
-    assert_exception(ArgumentError) {
+    assert_raises(ArgumentError) {
       "dir/abc.rb".pathmap("%z")
     }
   end
@@ -132,7 +126,7 @@ class TestPathMap < Test::Unit::TestCase
   end
 
   def test_pattern_with_invalid_operator
-    ex = assert_exception(ArgumentError) do
+    ex = assert_raises(ArgumentError) do
       "abc.xyz".pathmap("%{src,bin}z")
     end
     assert_match(/unknown.*pathmap.*spec.*z/i, ex.message)
@@ -161,51 +155,3 @@ class TestPathMap < Test::Unit::TestCase
   end
 end
 
-class TestPathMapExplode < Test::Unit::TestCase
-  def setup
-    String.class_eval { public :pathmap_explode }
-  end
-
-  def teardown
-    String.class_eval { protected :pathmap_explode }
-  end
-
-  def test_explode
-    assert_equal ['a'], 'a'.pathmap_explode
-    assert_equal ['a', 'b'], 'a/b'.pathmap_explode
-    assert_equal ['a', 'b', 'c'], 'a/b/c'.pathmap_explode
-    assert_equal ['/', 'a'], '/a'.pathmap_explode
-    assert_equal ['/', 'a', 'b'], '/a/b'.pathmap_explode
-    assert_equal ['/', 'a', 'b', 'c'], '/a/b/c'.pathmap_explode
-    if File::ALT_SEPARATOR
-      assert_equal ['c:.', 'a'], 'c:a'.pathmap_explode
-      assert_equal ['c:.', 'a', 'b'], 'c:a/b'.pathmap_explode
-      assert_equal ['c:.', 'a', 'b', 'c'], 'c:a/b/c'.pathmap_explode
-      assert_equal ['c:/', 'a'], 'c:/a'.pathmap_explode
-      assert_equal ['c:/', 'a', 'b'], 'c:/a/b'.pathmap_explode
-      assert_equal ['c:/', 'a', 'b', 'c'], 'c:/a/b/c'.pathmap_explode
-    end
-  end
-end
-
-class TestPathMapPartial < Test::Unit::TestCase
-  def test_pathmap_partial
-    @path = "1/2/file"
-    def @path.call(n)
-      pathmap_partial(n)
-    end
-    assert_equal("1", @path.call(1))
-    assert_equal("1/2", @path.call(2))
-    assert_equal("1/2", @path.call(3))
-    assert_equal(".", @path.call(0))
-    assert_equal("2", @path.call(-1))
-    assert_equal("1/2", @path.call(-2))
-    assert_equal("1/2", @path.call(-3))
-  end
-end
-
-class TestFileListPathMap < Test::Unit::TestCase
-  def test_file_list_supports_pathmap
-    assert_equal ['a', 'b'], FileList['dir/a.rb', 'dir/b.rb'].pathmap("%n")
-  end
-end

data/test/test_rake_path_map_explode.rb

@@ -0,0 +1,31 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestRakePathMapExplode < Rake::TestCase
+  def setup
+    super
+
+    String.class_eval { public :pathmap_explode }
+  end
+
+  def teardown
+    String.class_eval { protected :pathmap_explode }
+  end
+
+  def test_explode
+    assert_equal ['a'], 'a'.pathmap_explode
+    assert_equal ['a', 'b'], 'a/b'.pathmap_explode
+    assert_equal ['a', 'b', 'c'], 'a/b/c'.pathmap_explode
+    assert_equal ['/', 'a'], '/a'.pathmap_explode
+    assert_equal ['/', 'a', 'b'], '/a/b'.pathmap_explode
+    assert_equal ['/', 'a', 'b', 'c'], '/a/b/c'.pathmap_explode
+    if File::ALT_SEPARATOR
+      assert_equal ['c:.', 'a'], 'c:a'.pathmap_explode
+      assert_equal ['c:.', 'a', 'b'], 'c:a/b'.pathmap_explode
+      assert_equal ['c:.', 'a', 'b', 'c'], 'c:a/b/c'.pathmap_explode
+      assert_equal ['c:/', 'a'], 'c:/a'.pathmap_explode
+      assert_equal ['c:/', 'a', 'b'], 'c:/a/b'.pathmap_explode
+      assert_equal ['c:/', 'a', 'b', 'c'], 'c:/a/b/c'.pathmap_explode
+    end
+  end
+end
+

data/test/test_rake_path_map_partial.rb

@@ -0,0 +1,18 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestRakePathMapPartial < Rake::TestCase
+  def test_pathmap_partial
+    @path = "1/2/file"
+    def @path.call(n)
+      pathmap_partial(n)
+    end
+    assert_equal("1", @path.call(1))
+    assert_equal("1/2", @path.call(2))
+    assert_equal("1/2", @path.call(3))
+    assert_equal(".", @path.call(0))
+    assert_equal("2", @path.call(-1))
+    assert_equal("1/2", @path.call(-2))
+    assert_equal("1/2", @path.call(-3))
+  end
+end
+

data/test/{lib/pseudo_status_test.rb → test_rake_pseudo_status.rb}

@@ -1,12 +1,6 @@
-#!/usr/bin/env ruby
+require File.expand_path('../helper', __FILE__)
 
-require 'test/unit'
-require 'rake'
-
-require 'test/capture_stdout'
-require 'test/rake_test_setup'
-
-class PseudoStatusTest < Test::Unit::TestCase
+class TestRakePseudoStatus < Rake::TestCase
   def test_with_zero_exit_status
     s = Rake::PseudoStatus.new
     assert_equal 0, s.exitstatus

data/test/{lib/rdoc_task_test.rb → test_rake_rdoc_task.rb}

@@ -1,7 +1,4 @@
-#!/usr/bin/env ruby
-
-require 'test/unit'
-require 'test/capture_stdout'
+require File.expand_path('../helper', __FILE__)
 begin
   old_verbose = $VERBOSE
   $VERBOSE = nil
@@ -9,13 +6,13 @@ begin
 ensure
   $VERBOSE = old_verbose
 end
-require 'test/rake_test_setup'
 
-class TestRDocTask < Test::Unit::TestCase
+class TestRakeRDocTask < Rake::TestCase
   include Rake
-  include TestMethods
 
   def setup
+    super
+
     Task.clear
   end
 

data/test/{lib/require_test.rb → test_rake_require.rb}

@@ -1,12 +1,6 @@
-#!/usr/bin/env ruby
+require File.expand_path('../helper', __FILE__)
 
-require 'test/unit'
-require 'rake'
-require 'test/rake_test_setup'
-
-# ====================================================================
-class TestRequire < Test::Unit::TestCase
-  include TestMethods
+class TestRakeRequire < Rake::TestCase
 
   def test_can_load_rake_library
     app = Rake::Application.new
@@ -29,7 +23,7 @@ class TestRequire < Test::Unit::TestCase
 
   def test_throws_error_if_library_not_found
     app = Rake::Application.new
-    ex = assert_exception(LoadError) {
+    ex = assert_raises(LoadError) {
       assert app.instance_eval {
         rake_require("testx", ['test/data/rakelib'], [])
       }

data/test/{lib/rules_test.rb → test_rake_rules.rb}

@@ -1,16 +1,9 @@
-#!/usr/bin/env ruby
-
-require 'test/unit'
+require File.expand_path('../helper', __FILE__)
 require 'fileutils'
-require 'rake'
-require 'test/file_creation'
-require 'test/rake_test_setup'
 
 ######################################################################
-class TestRules < Test::Unit::TestCase
+class TestRakeRules < Rake::TestCase
   include Rake
-  include FileCreation
-  include TestMethods
 
   SRCFILE  = "testdata/abc.c"
   SRCFILE2 =  "testdata/xyz.c"
@@ -20,12 +13,17 @@ class TestRules < Test::Unit::TestCase
   DOTFOOFILE = "testdata/.foo"
 
   def setup
+    super
+
     Task.clear
     @runs = []
+    FileUtils.mkdir_p 'testdata' # HACK use tmpdir
   end
 
   def teardown
     FileList['testdata/*'].uniq.each do |f| rm_r(f, :verbose=>false) end
+
+    super
   end
 
   def test_multiple_rules1
@@ -192,8 +190,8 @@ class TestRules < Test::Unit::TestCase
     rule '.o' => ['.c'] do |t|
       @runs << t.name
     end
-    assert_exception(RuntimeError) { Task['testdata/x.obj'].invoke }
-    assert_exception(RuntimeError) { Task['testdata/x.xyo'].invoke }
+    assert_raises(RuntimeError) { Task['testdata/x.obj'].invoke }
+    assert_raises(RuntimeError) { Task['testdata/x.xyo'].invoke }
   end
 
   def test_rule_rebuilds_obj_when_source_is_newer
@@ -333,7 +331,7 @@ class TestRules < Test::Unit::TestCase
       rule ".#{letter}" => ".#{prev}" do |t| puts "#{t.name}" end
       prev = letter
     end
-    ex = assert_exception(Rake::RuleRecursionOverflowError) {
+    ex = assert_raises(Rake::RuleRecursionOverflowError) {
       Task["testdata/a.z"].invoke
     }
     assert_match(/a\.z => testdata\/a.y/, ex.message)
@@ -341,7 +339,7 @@ class TestRules < Test::Unit::TestCase
 
   def test_rules_with_bad_dependents_will_fail
     rule "a" => [ 1 ] do |t| puts t.name end
-    assert_exception(RuntimeError) do Task['a'].invoke end
+    assert_raises(RuntimeError) do Task['a'].invoke end
   end
 
 end

data/test/{lib/task_test.rb → test_rake_task.rb}

@@ -1,25 +1,20 @@
-#!/usr/bin/env ruby
-
-require 'test/unit'
+require File.expand_path('../helper', __FILE__)
 require 'fileutils'
-require 'rake'
-require 'test/rake_test_setup'
 
-######################################################################
-class TestTask < Test::Unit::TestCase
-  include CaptureStdout
+class TestRakeTask < Rake::TestCase
   include Rake
-  include TestMethods
-  include Rake::DSL
 
   def setup
+    super
+
     Task.clear
     Rake::TaskManager.record_task_metadata = true
   end
 
   def teardown
-    super
     Rake::TaskManager.record_task_metadata = false
+
+    super
   end
 
   def test_create
@@ -58,7 +53,7 @@ class TestTask < Test::Unit::TestCase
     t2 = task(:t2 => [:t1]) { |t| runlist << t.name }
     assert_equal ["t2"], t1.prerequisites
     assert_equal ["t1"], t2.prerequisites
-    ex = assert_exception RuntimeError do
+    ex = assert_raises RuntimeError do
       t1.invoke
     end
     assert_match(/circular dependency/i, ex.message)
@@ -69,10 +64,10 @@ class TestTask < Test::Unit::TestCase
     Rake.application.options.dryrun = true
     runlist = []
     t1 = task(:t1) { |t| runlist << t.name; 3321 }
-    out = capture_stderr { t1.invoke }
-    assert_match(/execute .*t1/i, out)
-    assert_match(/dry run/i, out)
-    assert_no_match(/invoke/i, out)
+    _, err = capture_io { t1.invoke }
+    assert_match(/execute .*t1/i, err)
+    assert_match(/dry run/i, err)
+    refute_match(/invoke/i, err)
     assert_equal [], runlist
   ensure
     Rake.application.options.dryrun = false
@@ -81,11 +76,11 @@ class TestTask < Test::Unit::TestCase
   def test_tasks_can_be_traced
     Rake.application.options.trace = true
     t1 = task(:t1)
-    out = capture_stderr {
+    _, err = capture_io {
       t1.invoke
     }
-    assert_match(/invoke t1/i, out)
-    assert_match(/execute t1/i, out)
+    assert_match(/invoke t1/i, err)
+    assert_match(/execute t1/i, err)
   ensure
     Rake.application.options.trace = false
   end
@@ -131,7 +126,7 @@ class TestTask < Test::Unit::TestCase
   def test_find
     task :tfind
     assert_equal "tfind", Task[:tfind].name
-    ex = assert_exception(RuntimeError) { Task[:leaves] }
+    ex = assert_raises(RuntimeError) { Task[:leaves] }
     assert_equal "Don't know how to build task 'leaves'", ex.message
   end
 
@@ -192,7 +187,7 @@ class TestTask < Test::Unit::TestCase
   def test_prerequiste_tasks_fails_if_prerequisites_are_undefined
     a = task :a => ["b", "c"]
     b = task :b
-    assert_exception(RuntimeError) do
+    assert_raises(RuntimeError) do
       a.prerequisite_tasks
     end
   end
@@ -274,164 +269,3 @@ class TestTask < Test::Unit::TestCase
   end
 end
 
-######################################################################
-class TestTaskWithArguments < Test::Unit::TestCase
-  include CaptureStdout
-  include Rake
-  include TestMethods
-  include Rake::DSL
-
-  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_exception 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
-    assert_nothing_raised do t.invoke(1) end
-    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