rake 0.8.3 → 0.8.4

data/test/test_filelist.rb

@@ -4,10 +4,12 @@ require 'test/unit'
 require 'rake'
 
 require 'test/capture_stdout'
+require 'test/rake_test_setup'
 
 class TestFileList < Test::Unit::TestCase
   FileList = Rake::FileList
   include CaptureStdout
+  include TestMethods
 
   def setup
     create_test_data
@@ -442,7 +444,7 @@ class TestFileList < Test::Unit::TestCase
     a = FileList['a', 'b', 'c']
     a.freeze
     c = a.clone
-    assert_raise(TypeError, RuntimeError) do
+    assert_exception(TypeError, RuntimeError) do
       c << 'more'
     end
   end

data/test/test_fileutils.rb

@@ -5,9 +5,11 @@ require 'test/unit'
 require 'test/filecreation'
 require 'fileutils'
 require 'stringio'
+require 'test/rake_test_setup'
 
 class TestFileUtils < Test::Unit::TestCase
   include FileCreation
+  include TestMethods
 
   def setup
     File.chmod(0750,"test/shellcommand.rb")
@@ -81,7 +83,7 @@ class TestFileUtils < Test::Unit::TestCase
   def test_safe_ln_fails_on_script_error
     FileUtils::LN_SUPPORTED[0] = true
     c = BadLink.new(ScriptError)
-    assert_raise(ScriptError) do c.safe_ln "a", "b" end
+    assert_exception(ScriptError) do c.safe_ln "a", "b" end
   end
 
   def test_verbose
@@ -114,8 +116,8 @@ class TestFileUtils < Test::Unit::TestCase
 
   def test_fileutils_methods_dont_leak
     obj = Object.new
-    assert_raise(NoMethodError) { obj.copy } # from FileUtils
-    assert_raise(NoMethodError) { obj.ruby } # from RubyFileUtils
+    assert_exception(NoMethodError) { obj.copy } # from FileUtils
+    assert_exception(NoMethodError) { obj.ruby } # from RubyFileUtils
   end
 
   def test_sh
@@ -123,21 +125,35 @@ class TestFileUtils < Test::Unit::TestCase
     assert true, "should not fail"
   end
 
+  # If the :sh method is invoked directly from a test unit instance
+  # (under mini/test), the mini/test version of fail is invoked rather
+  # than the kernel version of fail. So we run :sh from within a
+  # non-test class to avoid the problem.
+  class Sh
+    include FileUtils
+    def run(*args)
+      sh(*args)
+    end
+    def self.run(*args)
+      new.run(*args)
+    end
+  end
+
   def test_sh_multiple_arguments
     ENV['RAKE_TEST_SH'] = 'someval'
     expanded = windows? ? '%RAKE_TEST_SH%' : '$RAKE_TEST_SH'
     # This one gets expanded by the shell
     verbose(false) { sh %{ruby test/check_expansion.rb #{expanded} someval} }
     assert true, "should not fail"
-    assert_raises(RuntimeError) {
+    assert_exception(RuntimeError) {
       # This one does not get expanded
-      verbose(false) { sh 'ruby', 'test/check_expansion.rb', expanded, 'someval' }
+      verbose(false) { Sh.run 'ruby', 'test/check_expansion.rb', expanded, 'someval' }
     }
   end
 
   def test_sh_failure
-    assert_raises(RuntimeError) { 
-      verbose(false) { sh %{ruby test/shellcommand.rb 1} }
+    assert_exception(RuntimeError) { 
+      verbose(false) { Sh.run %{ruby test/shellcommand.rb 1} }
     }
   end
 
@@ -164,7 +180,7 @@ class TestFileUtils < Test::Unit::TestCase
   end
 
   def test_sh_bad_option
-    ex = assert_raise(ArgumentError) {
+    ex = assert_exception(ArgumentError) {
       verbose(false) { sh %{test/shellcommand.rb}, :bad_option=>true }
     }
     assert_match(/bad_option/, ex.message)
@@ -208,18 +224,14 @@ class TestFileUtils < Test::Unit::TestCase
       end
       assert block_run, "The block must be run"
 
-      if windows?
-        puts "SKIPPING test_ruby/part 2 when in windows"
-      else
-        # This one does not get expanded
-        block_run = false
-        ruby '-e', %{exit "#{env_var}".length} do |ok, status| # " (emacs wart)
-          assert(!ok)
-          assert_equal 15, status.exitstatus
-          block_run = true
-        end
-        assert block_run, "The block must be run"
+      # This one does not get expanded
+      block_run = false
+      ruby '-e', %{exit %{#{env_var}}.length} do |ok, status| # " (emacs wart)
+        assert(!ok)
+        assert_equal env_var.length, status.exitstatus
+        block_run = true
       end
+      assert block_run, "The block must be run"
     end
   end
 

data/test/test_invocation_chain.rb

@@ -2,9 +2,11 @@
 
 require 'test/unit'
 require 'rake'
+require 'test/rake_test_setup'
 
 ######################################################################
 class TestAnEmptyInvocationChain < Test::Unit::TestCase
+  include TestMethods
 
   def setup
     @empty = Rake::InvocationChain::EMPTY
@@ -23,6 +25,8 @@ end
 
 ######################################################################
 class TestAnInvocationChainWithOneMember < Test::Unit::TestCase
+  include TestMethods
+
   def setup
     @empty = Rake::InvocationChain::EMPTY
     @first_member = "A"
@@ -34,7 +38,7 @@ class TestAnInvocationChainWithOneMember < Test::Unit::TestCase
   end
 
   def test_should_fail_when_adding_original_member
-    ex = assert_raise RuntimeError do
+    ex = assert_exception RuntimeError do
       @chain.append(@first_member)
     end
     assert_match(/circular +dependency/i, ex.message)
@@ -49,6 +53,8 @@ end
 
 ######################################################################
 class TestAnInvocationChainWithMultipleMember < Test::Unit::TestCase
+  include TestMethods
+
   def setup
     @first_member = "A"
     @second_member = "B"
@@ -65,7 +71,7 @@ class TestAnInvocationChainWithMultipleMember < Test::Unit::TestCase
   end
 
   def test_should_fail_when_adding_original_member
-    ex = assert_raise RuntimeError do
+    ex = assert_exception RuntimeError do
       @chain.append(@first_member)
     end
     assert_match(/A.*=>.*B.*=>.*A/, ex.message)

data/test/test_makefile_loader.rb

@@ -20,6 +20,7 @@ class TestMakefileLoader < Test::Unit::TestCase
     assert_equal %w(d1 d2).sort, Task['d'].prerequisites.sort
     assert_equal %w(e1 f1).sort, Task['e'].prerequisites.sort
     assert_equal %w(e1 f1).sort, Task['f'].prerequisites.sort
-    assert_equal 6, Task.tasks.size
+    assert_equal ["g1", "g 2", "g 3", "g4"].sort, Task['g 0'].prerequisites.sort
+    assert_equal 7, Task.tasks.size
   end
 end

data/test/test_namespace.rb

@@ -9,28 +9,47 @@ end
 require 'test/unit'
 require 'flexmock/test_unit'
 require 'rake'
+require 'test/rake_test_setup'
 
 class TestNameSpace < Test::Unit::TestCase
+  include TestMethods
+
+  class TM
+    include Rake::TaskManager
+  end
 
   def test_namespace_creation
-    mgr = flexmock("TaskManager")
+    mgr = TM.new
     ns = Rake::NameSpace.new(mgr, [])
     assert_not_nil ns
   end
 
   def test_namespace_lookup
-    mgr = flexmock("TaskManager")
-    mgr.should_receive(:lookup).with(:t, ["a"]).
-      and_return(:dummy).once
-    ns = Rake::NameSpace.new(mgr, ["a"])
-    assert_equal :dummy, ns[:t]
+    mgr = TM.new
+    ns = mgr.in_namespace("n") do
+      mgr.define_task(Rake::Task, "t")
+    end
+
+    assert_not_nil ns["t"]
+    assert_equal mgr["n:t"], ns["t"]
   end
 
   def test_namespace_reports_tasks_it_owns
-    mgr = flexmock("TaskManager")
-    mgr.should_receive(:tasks).with().
-      and_return([:x, :y, :z]).once
-    ns = Rake::NameSpace.new(mgr, ["a"])
-    assert_equal [:x, :y, :z], ns.tasks
+    mgr = TM.new
+    nns = nil
+    ns = mgr.in_namespace("n") do
+      mgr.define_task(Rake::Task, :x)
+      mgr.define_task(Rake::Task, :y)
+      nns = mgr.in_namespace("nn") do
+        mgr.define_task(Rake::Task, :z)
+      end
+    end
+    mgr.in_namespace("m") do
+      mgr.define_task(Rake::Task, :x)
+    end
+
+    assert_equal ["n:nn:z", "n:x", "n:y"],
+      ns.tasks.map { |tsk| tsk.name }
+    assert_equal ["n:nn:z"], nns.tasks.map {|t| t.name}
   end
 end

data/test/test_package_task.rb

@@ -2,9 +2,11 @@
 
 require 'test/unit'
 require 'rake/packagetask'
+require 'test/rake_test_setup'
 
 class TestPackageTask < Test::Unit::TestCase
   include Rake
+  include TestMethods
 
   def test_create
     pkg = Rake::PackageTask.new("pkgr", "1.2.3") { |p|
@@ -40,7 +42,7 @@ class TestPackageTask < Test::Unit::TestCase
   end
 
   def test_missing_version
-    assert_raises(RuntimeError) {
+    assert_exception(RuntimeError) {
       pkg = Rake::PackageTask.new("pkgr") { |p| }
     }
   end

data/test/test_pathmap.rb

@@ -5,6 +5,7 @@ require 'rake'
 
 # ====================================================================
 class TestPathMap < Test::Unit::TestCase
+  include TestMethods
 
   def test_returns_self_with_no_args
     assert_equal "abc.rb", "abc.rb".pathmap
@@ -86,7 +87,7 @@ class TestPathMap < Test::Unit::TestCase
   end
 
   def test_undefined_percent_causes_error
-    ex = assert_raise(ArgumentError) {
+    ex = assert_exception(ArgumentError) {
       "dir/abc.rb".pathmap("%z")
     }
   end
@@ -130,7 +131,7 @@ class TestPathMap < Test::Unit::TestCase
   end
 
   def test_pattern_with_invalid_operator
-    ex = assert_raise(ArgumentError) do
+    ex = assert_exception(ArgumentError) do
       "abc.xyz".pathmap("%{src,bin}z")
     end
     assert_match(/unknown.*pathmap.*spec.*z/i, ex.message)

data/test/test_rdoc_task.rb

@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rake/rdoctask'
+require 'test/rake_test_setup'
+
+class TestRDocTask < Test::Unit::TestCase
+  include Rake
+  include TestMethods
+  
+  def setup
+    Task.clear
+  end
+  
+  def test_tasks_creation
+    Rake::RDocTask.new
+    assert Task[:rdoc]
+    assert Task[:clobber_rdoc]
+    assert Task[:rerdoc]
+  end
+  
+  def test_tasks_creation_with_custom_name_symbol
+    rd = Rake::RDocTask.new(:rdoc_dev)
+    assert Task[:rdoc_dev]
+    assert Task[:clobber_rdoc_dev]
+    assert Task[:rerdoc_dev]
+    assert_equal :rdoc_dev, rd.name
+  end
+  
+  def test_tasks_creation_with_custom_name_string
+    rd = Rake::RDocTask.new("rdoc_dev")
+    assert Task[:rdoc_dev]
+    assert Task[:clobber_rdoc_dev]
+    assert Task[:rerdoc_dev]
+    assert_equal "rdoc_dev", rd.name
+  end
+  
+  def test_tasks_creation_with_custom_name_hash
+    options = { :rdoc => "rdoc", :clobber_rdoc => "rdoc:clean", :rerdoc => "rdoc:force" }
+    rd = Rake::RDocTask.new(options)
+    assert Task[:"rdoc"]
+    assert Task[:"rdoc:clean"]
+    assert Task[:"rdoc:force"]
+    assert_raises(RuntimeError) { Task[:clobber_rdoc] }
+    assert_equal options, rd.name
+  end
+  
+  def test_tasks_creation_with_custom_name_hash_will_use_default_if_an_option_isnt_given
+    rd = Rake::RDocTask.new(:clobber_rdoc => "rdoc:clean")
+    assert Task[:rdoc]
+    assert Task[:"rdoc:clean"]
+    assert Task[:rerdoc]
+  end
+  
+  def test_tasks_creation_with_custom_name_hash_raises_exception_if_invalid_option_given
+    assert_raises(ArgumentError) do
+      Rake::RDocTask.new(:foo => "bar")
+    end
+    
+    begin
+      Rake::RDocTask.new(:foo => "bar")
+    rescue ArgumentError => e
+      assert_match(/foo/, e.message)
+    end
+  end
+  
+  def test_inline_source_is_enabled_by_default
+    rd = Rake::RDocTask.new
+    assert rd.option_list.include?('--inline-source')
+  end
+  
+  def test_inline_source_option_is_only_appended_if_option_not_already_given
+    rd = Rake::RDocTask.new
+    rd.options << '--inline-source'
+    assert_equal 1, rd.option_list.grep('--inline-source').size
+    
+    rd = Rake::RDocTask.new
+    rd.options << '-S'
+    assert_equal 1, rd.option_list.grep('-S').size
+    assert_equal 0, rd.option_list.grep('--inline-source').size
+  end
+  
+  def test_inline_source_option_can_be_disabled
+    rd = Rake::RDocTask.new
+    rd.inline_source = false
+    assert !rd.option_list.include?('--inline-source')
+  end
+end

data/test/test_require.rb

@@ -2,9 +2,11 @@
 
 require 'test/unit'
 require 'rake'
+require 'test/rake_test_setup'
 
 # ====================================================================
 class TestRequire < Test::Unit::TestCase
+  include TestMethods
 
   def test_can_load_rake_library
     app = Rake::Application.new
@@ -22,7 +24,7 @@ class TestRequire < Test::Unit::TestCase
 
   def test_throws_error_if_library_not_found
     app = Rake::Application.new
-    ex = assert_raise(LoadError) {
+    ex = assert_exception(LoadError) {
       assert app.instance_eval {
         rake_require("testx", ['test/data/rakelib'], [])
       }

data/test/test_rules.rb

@@ -4,11 +4,13 @@ require 'test/unit'
 require 'fileutils'
 require 'rake'
 require 'test/filecreation'
+require 'test/rake_test_setup'
 
 ######################################################################
 class TestRules < Test::Unit::TestCase
   include Rake
   include FileCreation
+  include TestMethods
 
   SRCFILE  = "testdata/abc.c"
   SRCFILE2 =  "testdata/xyz.c"
@@ -23,7 +25,7 @@ class TestRules < Test::Unit::TestCase
   end
 
   def teardown
-    FileList['testdata/*'].each do |f| rm_r(f, :verbose=>false) end
+    FileList['testdata/*'].uniq.each do |f| rm_r(f, :verbose=>false) end
   end
 
   def test_multiple_rules1
@@ -190,8 +192,8 @@ class TestRules < Test::Unit::TestCase
     rule '.o' => ['.c'] do |t|
       @runs << t.name
     end
-    assert_raises(RuntimeError) { Task['testdata/x.obj'].invoke }
-    assert_raises(RuntimeError) { Task['testdata/x.xyo'].invoke }
+    assert_exception(RuntimeError) { Task['testdata/x.obj'].invoke }
+    assert_exception(RuntimeError) { Task['testdata/x.xyo'].invoke }
   end
 
   def test_rule_rebuilds_obj_when_source_is_newer
@@ -332,7 +334,7 @@ class TestRules < Test::Unit::TestCase
       rule ".#{letter}" => ".#{prev}" do |t| puts "#{t.name}" end
       prev = letter
     end
-    ex = assert_raises(Rake::RuleRecursionOverflowError) {
+    ex = assert_exception(Rake::RuleRecursionOverflowError) {
       Task["testdata/a.z"].invoke
     }
     assert_match(/a\.z => testdata\/a.y/, ex.message)
@@ -340,7 +342,7 @@ class TestRules < Test::Unit::TestCase
 
   def test_rules_with_bad_dependents_will_fail
     rule "a" => [ 1 ] do |t| puts t.name end
-    assert_raise(RuntimeError) do Task['a'].invoke end
+    assert_exception(RuntimeError) do Task['a'].invoke end
   end
 
 end