rake 0.8.7 → 0.9.2

data/test/{test_filelist.rb → test_rake_file_list.rb}

@@ -1,26 +1,22 @@
-#!/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 TestFileList < Test::Unit::TestCase
+class TestRakeFileList < Rake::TestCase
   FileList = Rake::FileList
-  include CaptureStdout
-  include TestMethods
 
   def setup
+    super
+
     create_test_data
   end
 
   def teardown
 #    FileList.select_default_ignore_patterns
     FileUtils.rm_rf("testdata")
+
+    super
   end
 
-  def test_delgating_methods_do_not_include_to_a_or_to_ary
+  def test_delegating_methods_do_not_include_to_a_or_to_ary
     assert ! FileList::DELEGATING_METHODS.include?("to_a"), "should not include to_a"
     assert ! FileList::DELEGATING_METHODS.include?(:to_a), "should not include to_a"
     assert ! FileList::DELEGATING_METHODS.include?("to_ary"), "should not include to_ary"
@@ -87,11 +83,11 @@ class TestFileList < Test::Unit::TestCase
     h = f.include("y")
     assert_equal f.object_id, h.object_id
   end
-  
+
   def test_match
     fl = FileList.new
-    fl.include('test/test*.rb')
-    assert fl.include?("test/test_filelist.rb")
+    fl.include('test/test_*.rb')
+    assert fl.include?("test/test_rake_file_list.rb")
     assert fl.size > 3
     fl.each { |fn| assert_match(/\.rb$/, fn) }
   end
@@ -102,7 +98,7 @@ class TestFileList < Test::Unit::TestCase
     fl.include("test/*.rb")
     assert_equal "a.java", fl[0]
     assert fl.size > 2
-    assert fl.include?("test/test_filelist.rb")
+    assert fl.include?("test/test_rake_file_list.rb")
   end
 
   def test_multiple_patterns
@@ -153,7 +149,7 @@ class TestFileList < Test::Unit::TestCase
     fl.exclude('testdata/existing')
     assert_equal [], fl
   end
-  
+
   def test_excluding_via_block
     fl = FileList['testdata/a.c', 'testdata/b.c', 'testdata/xyz.c']
     fl.exclude { |fn| fn.pathmap('%n') == 'xyz' }
@@ -233,24 +229,24 @@ class TestFileList < Test::Unit::TestCase
     assert_equal ["testdata/abc.o", "testdata/x.o", "testdata/xyz.o"].sort,
       f3.sort
   end
-  
+
   def test_claim_to_be_a_kind_of_array
     fl = FileList['testdata/*.c']
     assert fl.is_a?(Array)
     assert fl.kind_of?(Array)
   end
-  
+
   def test_claim_to_be_a_kind_of_filelist
     fl = FileList['testdata/*.c']
     assert fl.is_a?(FileList)
     assert fl.kind_of?(FileList)
   end
-  
+
   def test_claim_to_be_a_filelist_instance
     fl = FileList['testdata/*.c']
     assert fl.instance_of?(FileList)
   end
-  
+
   def test_dont_claim_to_be_an_array_instance
     fl = FileList['testdata/*.c']
     assert ! fl.instance_of?(Array)
@@ -323,24 +319,38 @@ class TestFileList < Test::Unit::TestCase
       f.sort
   end
 
+  def test_egrep_returns_0_if_no_matches
+    files = FileList['test/lib/*_test.rb'].exclude("test/lib/filelist_test.rb")
+    assert_equal 0, files.egrep(/XYZZY/) { }
+  end
+
   def test_egrep_with_output
-    files = FileList['test/test*.rb']
+    files = FileList['test/test_*.rb']
     the_line_number = __LINE__ + 1
-    out = capture_stdout do files.egrep(/PUGH/) end
+    out, = capture_io do files.egrep(/PUGH/) end
     assert_match(/:#{the_line_number}:/, out)
   end
 
   def test_egrep_with_block
-    files = FileList['test/test*.rb']
-    found = false
+    files = FileList['test/test_*.rb']
+    found = nil
     the_line_number = __LINE__ + 1
     files.egrep(/XYZZY/) do |fn, ln, line |
-      assert_equal 'test/test_filelist.rb', fn
-      assert_equal the_line_number, ln
-      assert_match(/files\.egrep/, line)
-      found = true
+      found = [fn, ln, line]
+    end
+    assert_equal 'test/test_rake_file_list.rb', found[0]
+    assert_equal the_line_number, found[1]
+    assert_match(/files\.egrep/, found[2])
+  end
+
+  def test_egrep_with_error
+    files = FileList['test/test_*.rb']
+    _, err = capture_io do
+      files.egrep(/ANYTHING/) do |fn, ln, line |
+        fail "_EGREP_FAILURE_"
+      end
     end
-    assert found, "should have found a matching line"
+    assert_match(/_EGREP_FAILURE_/, err)
   end
 
   def test_existing
@@ -447,7 +457,7 @@ class TestFileList < Test::Unit::TestCase
     a = FileList['a', 'b', 'c']
     a.freeze
     c = a.clone
-    assert_exception(TypeError, RuntimeError) do
+    assert_raises(TypeError, RuntimeError) do
       c << 'more'
     end
   end
@@ -588,12 +598,12 @@ class TestFileList < Test::Unit::TestCase
     assert_equal ['b', 'd'], r
     assert_equal FileList, r.class
   end
-  
+
   def test_file_utils_can_use_filelists
     cfiles = FileList['testdata/*.c']
-    
+
     cp cfiles, @cdir, :verbose => false
-    
+
     assert File.exist?(File.join(@cdir, 'abc.c'))
     assert File.exist?(File.join(@cdir, 'xyz.c'))
     assert File.exist?(File.join(@cdir, 'x.c'))
@@ -601,7 +611,7 @@ class TestFileList < Test::Unit::TestCase
 
   def create_test_data
     verbose(false) do
-      
+
       mkdir "testdata" unless File.exist? "testdata"
       mkdir "testdata/CVS" rescue nil
       mkdir "testdata/.svn" rescue nil
@@ -619,5 +629,5 @@ class TestFileList < Test::Unit::TestCase
       touch "testdata/existing"
     end
   end
-  
+
 end

data/test/test_rake_file_list_path_map.rb

@@ -0,0 +1,8 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestRakeFileListPathMap < Rake::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_file_task.rb → test_rake_file_task.rb}

@@ -1,18 +1,12 @@
-#!/usr/bin/env ruby
-
-require 'test/unit'
+require File.expand_path('../helper', __FILE__)
 require 'fileutils'
-require 'rake'
-require 'test/filecreation'
-require 'test/rake_test_setup'
 
-######################################################################
-class TestFileTask < Test::Unit::TestCase
+class TestRakeFileTask < Rake::TestCase
   include Rake
-  include FileCreation
-  include TestMethods
 
   def setup
+    super
+
     Task.clear
     @runs = Array.new
     FileUtils.rm_f NEWFILE
@@ -20,15 +14,23 @@ class TestFileTask < Test::Unit::TestCase
   end
 
   def test_file_need
+    FileUtils.mkdir_p 'testdata' # HACK use tmpdir
+
     name = "testdata/dummy"
     file name
+
     ftask = Task[name]
+
     assert_equal name.to_s, ftask.name
     File.delete(ftask.name) rescue nil
+
     assert ftask.needed?, "file should be needed"
+
     open(ftask.name, "w") { |f| f.puts "HI" }
+
     assert_equal nil, ftask.prerequisites.collect{|n| Task[n].timestamp}.max
     assert ! ftask.needed?, "file should not be needed"
+  ensure
     File.delete(ftask.name) rescue nil
   end
 
@@ -66,18 +68,26 @@ class TestFileTask < Test::Unit::TestCase
   end
 
   def test_existing_file_depends_on_non_existing_file
+    @ran = false
+
     create_file(OLDFILE)
     delete_file(NEWFILE)
-    file NEWFILE
+    file NEWFILE do
+      @ran = true
+    end
+
     file OLDFILE => NEWFILE
-    assert_nothing_raised do Task[OLDFILE].invoke end
+
+    Task[OLDFILE].invoke
+
+    assert @ran
   end
 
   # I have currently disabled this test.  I'm not convinced that
   # deleting the file target on failure is always the proper thing to
   # do.  I'm willing to hear input on this topic.
   def ztest_file_deletes_on_failure
-    task :obj 
+    task :obj
     file NEWFILE => [:obj] do |t|
       FileUtils.touch NEWFILE
       fail "Ooops"
@@ -92,52 +102,3 @@ class TestFileTask < Test::Unit::TestCase
 
 end
 
-######################################################################
-class TestDirectoryTask < Test::Unit::TestCase
-  include Rake
-
-  def setup
-    rm_rf "testdata", :verbose=>false
-  end
-
-  def teardown
-    rm_rf "testdata", :verbose=>false
-  end
-
-  def test_directory
-    desc "DESC"
-    directory "testdata/a/b/c"
-    assert_equal FileCreationTask, Task["testdata"].class
-    assert_equal FileCreationTask, Task["testdata/a"].class
-    assert_equal FileCreationTask, Task["testdata/a/b/c"].class
-    assert_nil             Task["testdata"].comment
-    assert_equal "DESC",   Task["testdata/a/b/c"].comment
-    assert_nil             Task["testdata/a/b"].comment
-    verbose(false) {
-      Task['testdata/a/b'].invoke
-    }
-    assert File.exist?("testdata/a/b")
-    assert ! File.exist?("testdata/a/b/c")
-  end
-
-  if Rake::Win32.windows?
-    def test_directory_win32
-      desc "WIN32 DESC"
-      FileUtils.mkdir_p("testdata")
-      Dir.chdir("testdata") do
-        directory 'c:/testdata/a/b/c'
-        assert_equal FileCreationTask, Task['c:/testdata'].class
-        assert_equal FileCreationTask, Task['c:/testdata/a'].class
-        assert_equal FileCreationTask, Task['c:/testdata/a/b/c'].class
-        assert_nil             Task['c:/testdata'].comment
-        assert_equal "WIN32 DESC",   Task['c:/testdata/a/b/c'].comment
-        assert_nil             Task['c:/testdata/a/b'].comment
-        verbose(false) {
-          Task['c:/testdata/a/b'].invoke
-        }
-        assert File.exist?('c:/testdata/a/b')
-        assert ! File.exist?('c:/testdata/a/b/c')
-      end
-    end
-  end
-end

data/test/{test_fileutils.rb → test_rake_file_utils.rb}

@@ -1,25 +1,23 @@
-#!/usr/bin/env ruby
-
-require 'rake'
-require 'test/unit'
-require 'test/filecreation'
+require File.expand_path('../helper', __FILE__)
 require 'fileutils'
 require 'stringio'
-require 'test/rake_test_setup'
 
-class TestFileUtils < Test::Unit::TestCase
-  include FileCreation
-  include TestMethods
+class TestRakeFileUtils < Rake::TestCase
 
   def setup
-    File.chmod(0750,"test/shellcommand.rb")
+    super
+
+    File.chmod(0750, "test/shellcommand.rb")
   end
-  
+
   def teardown
+    File.chmod(0755, "test/shellcommand.rb")
     FileUtils.rm_rf("testdata")
     FileUtils::LN_SUPPORTED[0] = true
+
+    super
   end
-  
+
   def test_rm_one_file
     create_file("testdata/a")
     FileUtils.rm_rf "testdata/a"
@@ -45,12 +43,12 @@ class TestFileUtils < Test::Unit::TestCase
   def test_ln
     create_dir("testdata")
     open("testdata/a", "w") { |f| f.puts "TEST_LN" }
-    RakeFileUtils.safe_ln("testdata/a", "testdata/b", :verbose => false)
+    Rake::FileUtilsExt.safe_ln("testdata/a", "testdata/b", :verbose => false)
     assert_equal "TEST_LN\n", open("testdata/b") { |f| f.read }
   end
 
   class BadLink
-    include RakeFileUtils
+    include Rake::FileUtilsExt
     attr_reader :cp_args
     def initialize(klass)
       @failure_class = klass
@@ -83,7 +81,7 @@ class TestFileUtils < Test::Unit::TestCase
   def test_safe_ln_fails_on_script_error
     FileUtils::LN_SUPPORTED[0] = true
     c = BadLink.new(ScriptError)
-    assert_exception(ScriptError) do c.safe_ln "a", "b" end
+    assert_raises(ScriptError) do c.safe_ln "a", "b" end
   end
 
   def test_verbose
@@ -116,12 +114,12 @@ class TestFileUtils < Test::Unit::TestCase
 
   def test_fileutils_methods_dont_leak
     obj = Object.new
-    assert_exception(NoMethodError) { obj.copy } # from FileUtils
-    assert_exception(NoMethodError) { obj.ruby } # from RubyFileUtils
+    assert_raises(NoMethodError) { obj.copy } # from FileUtils
+    assert_raises(NoMethodError) { obj.ruby "-v" } # from RubyFileUtils
   end
 
   def test_sh
-    verbose(false) { sh %{ruby test/shellcommand.rb} }
+    verbose(false) { sh %{#{FileUtils::RUBY} test/shellcommand.rb} }
     assert true, "should not fail"
   end
 
@@ -137,37 +135,40 @@ class TestFileUtils < Test::Unit::TestCase
     def self.run(*args)
       new.run(*args)
     end
+    def self.ruby(*args)
+      Sh.run(RUBY, *args)
+    end
   end
 
   def test_sh_with_a_single_string_argument
     ENV['RAKE_TEST_SH'] = 'someval'
     verbose(false) {
-      sh %{ruby test/check_expansion.rb #{env_var} someval}
+      sh %{#{FileUtils::RUBY} test/check_expansion.rb #{env_var} someval}
     }
   end
 
   def test_sh_with_multiple_arguments
     ENV['RAKE_TEST_SH'] = 'someval'
     verbose(false) {
-      Sh.run 'ruby', 'test/check_no_expansion.rb', env_var, 'someval'
+      Sh.ruby 'test/check_no_expansion.rb', env_var, 'someval'
     }
   end
 
   def test_sh_failure
-    assert_exception(RuntimeError) { 
-      verbose(false) { Sh.run %{ruby test/shellcommand.rb 1} }
+    assert_raises(RuntimeError) {
+      verbose(false) { Sh.run %{#{FileUtils::RUBY} test/shellcommand.rb 1} }
     }
   end
 
   def test_sh_special_handling
     count = 0
     verbose(false) {
-      sh(%{ruby test/shellcommand.rb}) do |ok, res|
+      sh(%{#{FileUtils::RUBY} test/shellcommand.rb}) do |ok, res|
         assert(ok)
         assert_equal 0, res.exitstatus
         count += 1
       end
-      sh(%{ruby test/shellcommand.rb 1}) do |ok, res|
+      sh(%{#{FileUtils::RUBY} test/shellcommand.rb 1}) do |ok, res|
         assert(!ok)
         assert_equal 1, res.exitstatus
         count += 1
@@ -182,7 +183,7 @@ class TestFileUtils < Test::Unit::TestCase
   end
 
   def test_sh_bad_option
-    ex = assert_exception(ArgumentError) {
+    ex = assert_raises(ArgumentError) {
       verbose(false) { sh %{test/shellcommand.rb}, :bad_option=>true }
     }
     assert_match(/bad_option/, ex.message)
@@ -221,16 +222,16 @@ class TestFileUtils < Test::Unit::TestCase
   end
 
   def test_split_all
-    assert_equal ['a'], RakeFileUtils.split_all('a')
-    assert_equal ['..'], RakeFileUtils.split_all('..')
-    assert_equal ['/'], RakeFileUtils.split_all('/')
-    assert_equal ['a', 'b'], RakeFileUtils.split_all('a/b')
-    assert_equal ['/', 'a', 'b'], RakeFileUtils.split_all('/a/b')
-    assert_equal ['..', 'a', 'b'], RakeFileUtils.split_all('../a/b')
+    assert_equal ['a'], Rake::FileUtilsExt.split_all('a')
+    assert_equal ['..'], Rake::FileUtilsExt.split_all('..')
+    assert_equal ['/'], Rake::FileUtilsExt.split_all('/')
+    assert_equal ['a', 'b'], Rake::FileUtilsExt.split_all('a/b')
+    assert_equal ['/', 'a', 'b'], Rake::FileUtilsExt.split_all('/a/b')
+    assert_equal ['..', 'a', 'b'], Rake::FileUtilsExt.split_all('../a/b')
   end
 
   private
-  
+
   def redirect_stderr
     old_err = $stderr
     $stderr = StringIO.new
@@ -247,5 +248,5 @@ class TestFileUtils < Test::Unit::TestCase
   def env_var
     windows? ? '%RAKE_TEST_SH%' : '$RAKE_TEST_SH'
   end
-  
+
 end

data/test/{test_ftp.rb → test_rake_ftp_file.rb}

@@ -1,8 +1,6 @@
-#!/usr/bin/env ruby
-
+require File.expand_path('../helper', __FILE__)
 require 'date'
 require 'time'
-require 'test/unit'
 require 'rake/contrib/ftptools'
 
 class FakeDate
@@ -14,10 +12,11 @@ class FakeDate
   end
 end
 
-
-class TestFtpFile < Test::Unit::TestCase
+class TestRakeFtpFile < Rake::TestCase
 
   def setup
+    super
+
     Rake::FtpFile.class_eval { @date_class = FakeDate; @time_class = FakeDate }
   end
 
@@ -57,3 +56,4 @@ class TestFtpFile < Test::Unit::TestCase
     assert !file.directory?
   end
 end
+