rake 0.9.2 → 0.9.2.2

data/test/test_rake_file_task.rb

@@ -14,9 +14,7 @@ class TestRakeFileTask < Rake::TestCase
   end
 
   def test_file_need
-    FileUtils.mkdir_p 'testdata' # HACK use tmpdir
-
-    name = "testdata/dummy"
+    name = "dummy"
     file name
 
     ftask = Task[name]

data/test/test_rake_file_utils.rb

@@ -4,47 +4,41 @@ require 'stringio'
 
 class TestRakeFileUtils < Rake::TestCase
 
-  def setup
-    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
+    RakeFileUtils.verbose_flag = Rake::FileUtilsExt::DEFAULT
 
     super
   end
 
   def test_rm_one_file
-    create_file("testdata/a")
-    FileUtils.rm_rf "testdata/a"
-    assert ! File.exist?("testdata/a")
+    create_file("a")
+    FileUtils.rm_rf "a"
+    refute File.exist?("a")
   end
 
   def test_rm_two_files
-    create_file("testdata/a")
-    create_file("testdata/b")
-    FileUtils.rm_rf ["testdata/a", "testdata/b"]
-    assert ! File.exist?("testdata/a")
-    assert ! File.exist?("testdata/b")
+    create_file("a")
+    create_file("b")
+    FileUtils.rm_rf ["a", "b"]
+    refute File.exist?("a")
+    refute File.exist?("b")
   end
 
   def test_rm_filelist
-    list = Rake::FileList.new << "testdata/a" << "testdata/b"
+    list = Rake::FileList.new << "a" << "b"
     list.each { |fn| create_file(fn) }
     FileUtils.rm_r list
-    assert ! File.exist?("testdata/a")
-    assert ! File.exist?("testdata/b")
+    refute File.exist?("a")
+    refute File.exist?("b")
   end
 
   def test_ln
-    create_dir("testdata")
-    open("testdata/a", "w") { |f| f.puts "TEST_LN" }
-    Rake::FileUtilsExt.safe_ln("testdata/a", "testdata/b", :verbose => false)
-    assert_equal "TEST_LN\n", open("testdata/b") { |f| f.read }
+    open("a", "w") { |f| f.puts "TEST_LN" }
+
+    Rake::FileUtilsExt.safe_ln("a", "b", :verbose => false)
+
+    assert_equal "TEST_LN\n", File.read('b')
   end
 
   class BadLink
@@ -107,9 +101,13 @@ class TestRakeFileUtils < Rake::TestCase
   end
 
   def test_file_utils_methods_are_available_at_top_level
-    create_file("testdata/a")
-    rm_rf "testdata/a"
-    assert ! File.exist?("testdata/a")
+    create_file("a")
+
+    capture_io do
+      rm_rf "a"
+    end
+
+    refute File.exist?("a")
   end
 
   def test_fileutils_methods_dont_leak
@@ -119,56 +117,49 @@ class TestRakeFileUtils < Rake::TestCase
   end
 
   def test_sh
-    verbose(false) { sh %{#{FileUtils::RUBY} test/shellcommand.rb} }
-    assert true, "should not fail"
-  end
+    shellcommand
 
-  # 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
-    def self.ruby(*args)
-      Sh.run(RUBY, *args)
-    end
+    verbose(false) { sh %{#{Rake::TestCase::RUBY} shellcommand.rb} }
+    assert true, "should not fail"
   end
 
   def test_sh_with_a_single_string_argument
+    check_expansion
+
     ENV['RAKE_TEST_SH'] = 'someval'
     verbose(false) {
-      sh %{#{FileUtils::RUBY} test/check_expansion.rb #{env_var} someval}
+      sh %{#{RUBY} check_expansion.rb #{env_var} someval}
     }
   end
 
   def test_sh_with_multiple_arguments
+    check_no_expansion
     ENV['RAKE_TEST_SH'] = 'someval'
+
     verbose(false) {
-      Sh.ruby 'test/check_no_expansion.rb', env_var, 'someval'
+      sh RUBY, 'check_no_expansion.rb', env_var, 'someval'
     }
   end
 
   def test_sh_failure
+    shellcommand
+
     assert_raises(RuntimeError) {
-      verbose(false) { Sh.run %{#{FileUtils::RUBY} test/shellcommand.rb 1} }
+      verbose(false) { sh %{#{RUBY} shellcommand.rb 1} }
     }
   end
 
   def test_sh_special_handling
+    shellcommand
+
     count = 0
     verbose(false) {
-      sh(%{#{FileUtils::RUBY} test/shellcommand.rb}) do |ok, res|
+      sh(%{#{RUBY} shellcommand.rb}) do |ok, res|
         assert(ok)
         assert_equal 0, res.exitstatus
         count += 1
       end
-      sh(%{#{FileUtils::RUBY} test/shellcommand.rb 1}) do |ok, res|
+      sh(%{#{RUBY} shellcommand.rb 1}) do |ok, res|
         assert(!ok)
         assert_equal 1, res.exitstatus
         count += 1
@@ -178,46 +169,75 @@ class TestRakeFileUtils < Rake::TestCase
   end
 
   def test_sh_noop
-    verbose(false) { sh %{test/shellcommand.rb 1}, :noop=>true }
+    shellcommand
+
+    verbose(false) { sh %{shellcommand.rb 1}, :noop=>true }
     assert true, "should not fail"
   end
 
   def test_sh_bad_option
+    shellcommand
+
     ex = assert_raises(ArgumentError) {
-      verbose(false) { sh %{test/shellcommand.rb}, :bad_option=>true }
+      verbose(false) { sh %{shellcommand.rb}, :bad_option=>true }
     }
     assert_match(/bad_option/, ex.message)
   end
 
   def test_sh_verbose
-    out = redirect_stderr {
+    shellcommand
+
+    _, err = capture_io do
       verbose(true) {
-        sh %{test/shellcommand.rb}, :noop=>true
+        sh %{shellcommand.rb}, :noop=>true
       }
-    }
-    assert_match(/^test\/shellcommand\.rb$/, out)
+    end
+
+    assert_equal "shellcommand.rb\n", err
   end
 
-  def test_sh_no_verbose
-    out = redirect_stderr {
+  def test_sh_verbose_false
+    shellcommand
+
+    _, err = capture_io do
       verbose(false) {
-        sh %{test/shellcommand.rb}, :noop=>true
+        sh %{shellcommand.rb}, :noop=>true
       }
-    }
-    assert_equal '', out
+    end
+
+    assert_equal '', err
+  end
+
+  def test_sh_verbose_flag_nil
+    shellcommand
+
+    RakeFileUtils.verbose_flag = nil
+
+    assert_silent do
+      sh %{shellcommand.rb}, :noop=>true
+    end
   end
 
   def test_ruby_with_a_single_string_argument
+    check_expansion
+
     ENV['RAKE_TEST_SH'] = 'someval'
+
     verbose(false) {
-      ruby %{test/check_expansion.rb #{env_var} someval}
+      replace_ruby {
+        ruby %{check_expansion.rb #{env_var} someval}
+      }
     }
   end
 
   def test_ruby_with_multiple_arguments
+    check_no_expansion
+
     ENV['RAKE_TEST_SH'] = 'someval'
     verbose(false) {
-      ruby 'test/check_no_expansion.rb', env_var, 'someval'
+      replace_ruby {
+        ruby 'check_no_expansion.rb', env_var, 'someval'
+      }
     }
   end
 
@@ -230,23 +250,56 @@ class TestRakeFileUtils < Rake::TestCase
     assert_equal ['..', 'a', 'b'], Rake::FileUtilsExt.split_all('../a/b')
   end
 
-  private
+  def command name, text
+    open name, 'w', 0750 do |io|
+      io << text
+    end
+  end
 
-  def redirect_stderr
-    old_err = $stderr
-    $stderr = StringIO.new
+  def check_no_expansion
+    command 'check_no_expansion.rb', <<-CHECK_EXPANSION
+if ARGV[0] != ARGV[1]
+  exit 0
+else
+  exit 1
+end
+    CHECK_EXPANSION
+  end
+
+  def check_expansion
+    command 'check_expansion.rb', <<-CHECK_EXPANSION
+if ARGV[0] != ARGV[1]
+  exit 1
+else
+  exit 0
+end
+    CHECK_EXPANSION
+  end
+
+  def replace_ruby
+    ruby = FileUtils::RUBY
+    FileUtils.send :remove_const, :RUBY
+    FileUtils.const_set :RUBY, RUBY
     yield
-    $stderr.string
   ensure
-    $stderr = old_err
+    FileUtils.send :remove_const, :RUBY
+    FileUtils.const_set:RUBY, ruby
   end
 
-  def windows?
-    ! File::ALT_SEPARATOR.nil?
+  def shellcommand
+    command 'shellcommand.rb', <<-SHELLCOMMAND
+#!/usr/bin/env ruby
+
+exit((ARGV[0] || "0").to_i)
+    SHELLCOMMAND
   end
 
   def env_var
     windows? ? '%RAKE_TEST_SH%' : '$RAKE_TEST_SH'
   end
 
+  def windows?
+    ! File::ALT_SEPARATOR.nil?
+  end
+
 end

data/test/test_rake_functional.rb

@@ -1,91 +1,64 @@
-begin
-  old_verbose = $VERBOSE
-  $VERBOSE = nil
-  require 'session'
-rescue LoadError
-  if File::ALT_SEPARATOR
-    puts "Unable to run functional tests on MS Windows. Skipping."
-  else
-    puts "Unable to run functional tests -- please run \"gem install session\""
-  end
-ensure
-  $VERBOSE = old_verbose
-end
-
-if defined?(Session)
-  if File::ALT_SEPARATOR
-    puts "Unable to run functional tests on MS Windows. Skipping."
-  end
-end
-
 require File.expand_path('../helper', __FILE__)
 require 'fileutils'
-
-# Version 2.1.9 of session has a bug where the @debug instance
-# variable is not initialized, causing warning messages.  This snippet
-# of code fixes that problem.
-module Session
-  class AbstractSession
-    alias old_initialize initialize
-    def initialize(*args)
-      @debug = nil
-      old_initialize(*args)
-    end
-  end
-end if defined? Session
+require 'open3'
 
 class TestRakeFunctional < Rake::TestCase
 
-  RUBY_COMMAND = 'ruby'
-
   def setup
-    super
-
     @rake_path = File.expand_path("bin/rake")
     lib_path = File.expand_path("lib")
     @ruby_options = ["-I#{lib_path}", "-I."]
-    @verbose = ! ENV['VERBOSE'].nil?
+    @verbose = ENV['VERBOSE']
 
     if @verbose
       puts
       puts
-      puts "--------------------------------------------------------------------"
-      puts name
-      puts "--------------------------------------------------------------------"
+      puts '-' * 80
+      puts @__name__
+      puts '-' * 80
     end
+
+    super
   end
 
   def test_rake_default
-    Dir.chdir("test/data/default") do rake end
+    rakefile_default
+
+    rake
+
     assert_match(/^DEFAULT$/, @out)
-    assert_status
   end
 
   def test_rake_error_on_bad_task
-    Dir.chdir("test/data/default") do rake "xyz" end
+    rakefile_default
+
+    rake '-t', 'xyz'
+
     assert_match(/rake aborted/, @err)
-    assert_status(1)
   end
 
   def test_env_available_at_top_scope
-    Dir.chdir("test/data/default") do rake "TESTTOPSCOPE=1" end
+    rakefile_default
+
+    rake "TESTTOPSCOPE=1"
+
     assert_match(/^TOPSCOPE$/, @out)
-    assert_status
   end
 
   def test_env_available_at_task_scope
-    Dir.chdir("test/data/default") do rake "TESTTASKSCOPE=1 task_scope" end
+    rakefile_default
+
+    rake 'TESTTASKSCOPE=1', 'task_scope'
+
     assert_match(/^TASKSCOPE$/, @out)
-    assert_status
   end
 
   def test_multi_desc
-    in_environment(
-      'RAKE_COLUMNS' => "80",
-      "PWD" => "test/data/multidesc"
-      ) do
-      rake "-T"
-    end
+    ENV['RAKE_COLUMNS'] = '80'
+    rakefile_multidesc
+
+    rake "-T"
+
     assert_match %r{^rake a *# A / A2 *$}, @out
     assert_match %r{^rake b *# B *$}, @out
     refute_match %r{^rake c}, @out
@@ -93,9 +66,10 @@ class TestRakeFunctional < Rake::TestCase
   end
 
   def test_long_description
-    in_environment("PWD" => "test/data/multidesc") do
-      rake "--describe"
-    end
+    rakefile_multidesc
+
+    rake "--describe"
+
     assert_match %r{^rake a\n *A / A2 *$}m, @out
     assert_match %r{^rake b\n *B *$}m, @out
     assert_match %r{^rake d\n *x{80}}m, @out
@@ -103,136 +77,159 @@ class TestRakeFunctional < Rake::TestCase
   end
 
   def test_proper_namespace_access
-    in_environment("PWD" => "test/data/access") do
-      rake
-    end
-    assert_not_match %r{^BAD:}, @out
+    rakefile_access
+
+    rake
+
+    refute_match %r{^BAD:}, @out
   end
 
   def test_rbext
-    in_environment("PWD" => "test/data/rbext") do
-      rake "-N"
-    end
+    rakefile_rbext
+
+    rake "-N"
+
     assert_match %r{^OK$}, @out
   end
 
   def test_system
-    in_environment('RAKE_SYSTEM' => 'test/data/sys') do
-      rake '-g', "sys1"
-    end
+    rake_system_dir
+
+    rake '-g', "sys1"
+
     assert_match %r{^SYS1}, @out
   end
 
   def test_system_excludes_rakelib_files_too
-    in_environment('RAKE_SYSTEM' => 'test/data/sys') do
-      rake '-g', "sys1", '-T', 'extra'
-    end
+    rake_system_dir
+
+    rake '-g', "sys1", '-T', 'extra'
+
     refute_match %r{extra:extra}, @out
   end
 
   def test_by_default_rakelib_files_are_included
-    in_environment('RAKE_SYSTEM' => 'test/data/sys', "PWD" => 'test/data/extra') do
-      rake '-T', 'extra', '--trace'
-    end
+    rake_system_dir
+    rakefile_extra
+
+    rake '-T', 'extra', '--trace'
+
     assert_match %r{extra:extra}, @out
   end
 
   def test_implicit_system
-    in_environment('RAKE_SYSTEM' => File.expand_path('test/data/sys'), "PWD" => "/") do
-      rake "sys1", "--trace"
-    end
+    rake_system_dir
+    Dir.chdir @tempdir
+
+    rake "sys1", "--trace"
+
     assert_match %r{^SYS1}, @out
   end
 
   def test_no_system
-    in_environment('RAKE_SYSTEM' => 'test/data/sys', "PWD" => "test/data/extra") do
-      rake '-G', "sys1"
-    end
+    rake_system_dir
+    rakefile_extra
+
+    rake '-G', "sys1"
+
     assert_match %r{^Don't know how to build task}, @err # emacs wart: '
   end
 
   def test_nosearch_with_rakefile_uses_local_rakefile
-    in_environment("PWD" => "test/data/default") do
-      rake "--nosearch"
-    end
+    rakefile_default
+
+    rake "--nosearch"
+
     assert_match %r{^DEFAULT}, @out
   end
 
   def test_nosearch_without_rakefile_finds_system
-    in_environment(
-      "PWD" => "test/data/nosearch",
-      "RAKE_SYSTEM" => File.expand_path("test/data/sys")
-      ) do
-      rake "--nosearch", "sys1"
-    end
+    rakefile_nosearch
+    rake_system_dir
+
+    rake "--nosearch", "sys1"
+
     assert_match %r{^SYS1}, @out
   end
 
   def test_nosearch_without_rakefile_and_no_system_fails
-    in_environment("PWD" => "test/data/nosearch", "RAKE_SYSTEM" => "not_exist") do
-      rake "--nosearch"
-    end
+    rakefile_nosearch
+    ENV['RAKE_SYSTEM'] = 'not_exist'
+
+    rake "--nosearch"
+
     assert_match %r{^No Rakefile found}, @err
   end
 
   def test_invalid_command_line_options
-    in_environment("PWD" => "test/data/default") do
-      rake "--bad-options"
-    end
+    rakefile_default
+
+    rake "--bad-options"
+
     assert_match %r{invalid +option}i, @err
   end
 
   def test_inline_verbose_default_should_show_command
-    in_environment("PWD" => "test/data/verbose") do
-      rake "inline_verbose_default"
-    end
-    assert_match(/ruby -e/, @err)
+    rakefile_verbose
+
+    rake "inline_verbose_default"
+
+    assert_match(/#{Regexp.quote(RUBY)} -e/, @err)
   end
 
   def test_inline_verbose_true_should_show_command
-    in_environment("PWD" => "test/data/verbose") do
-      rake "inline_verbose_true"
-    end
-    assert_match(/ruby -e/, @err)
+    rakefile_verbose
+
+    rake "inline_verbose_true"
+
+    assert_match(/#{Regexp.quote(RUBY)} -e/, @err)
   end
 
   def test_inline_verbose_false_should_not_show_command
-    in_environment("PWD" => "test/data/verbose") do
-      rake "inline_verbose_false"
-    end
-    refute_match(/ruby -e/, @err)
+    rakefile_verbose
+
+    rake "inline_verbose_false"
+
+    refute_match(/#{Regexp.quote(RUBY)} -e/, @err)
   end
 
   def test_block_verbose_false_should_not_show_command
-    in_environment("PWD" => "test/data/verbose") do
-      rake "block_verbose_false"
-    end
-    refute_match(/ruby -e/, @err)
+    rakefile_verbose
+
+    rake "block_verbose_false"
+
+    refute_match(/#{Regexp.quote(RUBY)} -e/, @err)
   end
 
   def test_block_verbose_true_should_show_command
-    in_environment("PWD" => "test/data/verbose") do
-      rake "block_verbose_true"
-    end
-    assert_match(/ruby -e/, @err)
+    rakefile_verbose
+
+    rake "block_verbose_true"
+
+    assert_match(/#{Regexp.quote(RUBY)} -e/, @err)
   end
 
   def test_standalone_verbose_true_should_show_command
-    in_environment("PWD" => "test/data/verbose") do
-      rake "standalone_verbose_true"
-    end
-    assert_match(/ruby -e/, @err)
+    rakefile_verbose
+
+    rake "standalone_verbose_true"
+
+    assert_match(/#{Regexp.quote(RUBY)} -e/, @err)
   end
 
   def test_standalone_verbose_false_should_not_show_command
-    in_environment("PWD" => "test/data/verbose") do
-      rake "standalone_verbose_false"
-    end
-    refute_match(/ruby -e/, @err)
+    rakefile_verbose
+
+    rake "standalone_verbose_false"
+
+    refute_match(/#{Regexp.quote(RUBY)} -e/, @err)
   end
 
   def test_dry_run
-    in_environment("PWD" => "test/data/default") do rake "-n", "other" end
+    rakefile_default
+
+    rake "-n", "other"
+
     assert_match %r{Execute \(dry run\) default}, @err
     assert_match %r{Execute \(dry run\) other}, @err
     refute_match %r{DEFAULT}, @out
@@ -241,228 +238,213 @@ class TestRakeFunctional < Rake::TestCase
 
   # Test for the trace/dry_run bug found by Brian Chandler
   def test_dry_run_bug
-    in_environment("PWD" => "test/data/dryrun") do
-      rake
-    end
-    FileUtils.rm_f "test/data/dryrun/temp_one"
-    in_environment("PWD" => "test/data/dryrun") do
-      rake "--dry-run"
-    end
+    rakefile_dryrun
+
+    rake
+
+    FileUtils.rm_f 'temp_one'
+
+    rake "--dry-run"
+
     refute_match(/No such file/, @out)
-    assert_status
   end
 
   # Test for the trace/dry_run bug found by Brian Chandler
   def test_trace_bug
-    in_environment("PWD" => "test/data/dryrun") do
-      rake
-    end
-    FileUtils.rm_f "test/data/dryrun/temp_one"
-    in_environment("PWD" => "test/data/dryrun") do
-      rake "--trace"
-    end
+    rakefile_dryrun
+
+    rake
+
+    FileUtils.rm_f 'temp_one'
+
+    rake "--trace"
+
     refute_match(/No such file/, @out)
-    assert_status
   end
 
   def test_imports
-    open("test/data/imports/static_deps", "w") do |f|
-      f.puts 'puts "STATIC"'
-    end
-    FileUtils.rm_f "test/data/imports/dynamic_deps"
-    in_environment("PWD" => "test/data/imports") do
-      rake
-    end
-    assert File.exist?("test/data/imports/dynamic_deps"),
-      "'dynamic_deps' file should exist"
+    rakefile_imports
+
+    rake
+
+    assert File.exist?(File.join(@tempdir, 'dynamic_deps')),
+           "'dynamic_deps' file should exist"
     assert_match(/^FIRST$\s+^DYNAMIC$\s+^STATIC$\s+^OTHER$/, @out)
-    assert_status
-    FileUtils.rm_f "test/data/imports/dynamic_deps"
-    FileUtils.rm_f "test/data/imports/static_deps"
   end
 
   def test_rules_chaining_to_file_task
-    remove_chaining_files
-    in_environment("PWD" => "test/data/chains") do
-      rake
-    end
-    assert File.exist?("test/data/chains/play.app"),
-      "'play.app' file should exist"
-    assert_status
-    remove_chaining_files
+    rakefile_chains
+
+    rake
+
+    assert File.exist?(File.join(@tempdir, 'play.app')),
+           "'play.app' file should exist"
   end
 
   def test_file_creation_task
-    in_environment("PWD" => "test/data/file_creation_task") do
-      rake "prep"
-      rake "run"
-      rake "run"
-    end
+    rakefile_file_creation
+
+    rake "prep"
+    rake "run"
+    rake "run"
+
     assert(@err !~ /^cp src/, "Should not recopy data")
   end
 
   def test_dash_f_with_no_arg_foils_rakefile_lookup
-    rake "-I test/data/rakelib -rtest1 -f"
+    rakefile_rakelib
+
+    rake '-I', 'rakelib', '-rtest1', '-f'
+
     assert_match(/^TEST1$/, @out)
   end
 
   def test_dot_rake_files_can_be_loaded_with_dash_r
-    rake "-I test/data/rakelib -rtest2 -f"
+    rakefile_rakelib
+
+    rake '-I', 'rakelib', '-rtest2', '-f'
+
+    assert_empty @err
     assert_match(/^TEST2$/, @out)
   end
 
   def test_can_invoke_task_in_toplevel_namespace
-    in_environment("PWD" => "test/data/namespace") do
-      rake "copy"
-    end
+    rakefile_namespace
+
+    rake "copy"
+
     assert_match(/^COPY$/, @out)
   end
 
   def test_can_invoke_task_in_nested_namespace
-    in_environment("PWD" => "test/data/namespace") do
-      rake "nest:copy"
-      assert_match(/^NEST COPY$/, @out)
-    end
+    rakefile_namespace
+
+    rake "nest:copy"
+
+    assert_match(/^NEST COPY$/, @out)
   end
 
   def test_tasks_can_reference_task_in_same_namespace
-    in_environment("PWD" => "test/data/namespace") do
-      rake "nest:xx"
-      assert_match(/^NEST COPY$/m, @out)
-    end
+    rakefile_namespace
+
+    rake "nest:xx"
+
+    assert_match(/^NEST COPY$/m, @out)
   end
 
   def test_tasks_can_reference_task_in_other_namespaces
-    in_environment("PWD" => "test/data/namespace") do
-      rake "b:run"
-      assert_match(/^IN A\nIN B$/m, @out)
-    end
+    rakefile_namespace
+
+    rake "b:run"
+
+    assert_match(/^IN A\nIN B$/m, @out)
   end
 
   def test_anonymous_tasks_can_be_invoked_indirectly
-    in_environment("PWD" => "test/data/namespace") do
-      rake "anon"
-      assert_match(/^ANON COPY$/m, @out)
-    end
+    rakefile_namespace
+
+    rake "anon"
+
+    assert_match(/^ANON COPY$/m, @out)
   end
 
   def test_rake_namespace_refers_to_toplevel
-    in_environment("PWD" => "test/data/namespace") do
-      rake "very:nested:run"
-      assert_match(/^COPY$/m, @out)
-    end
+    rakefile_namespace
+
+    rake "very:nested:run"
+
+    assert_match(/^COPY$/m, @out)
   end
 
   def test_file_task_are_not_scoped_by_namespaces
-    in_environment("PWD" => "test/data/namespace") do
-      rake "xyz.rb"
-      assert_match(/^XYZ1\nXYZ2$/m, @out)
-    end
+    rakefile_namespace
+
+    rake "xyz.rb"
+
+    assert_match(/^XYZ1\nXYZ2$/m, @out)
   end
 
   def test_file_task_dependencies_scoped_by_namespaces
-    in_environment("PWD" => "test/data/namespace") do
-      rake "scopedep.rb"
-      assert_match(/^PREPARE\nSCOPEDEP$/m, @out)
-    end
-  ensure
-    remove_namespace_files
-  end
+    rakefile_namespace
 
-  def test_rake_returns_status_error_values
-    in_environment("PWD" => "test/data/statusreturn") do
-      rake "exit5"
-      assert_status(5)
-    end
-  end
+    rake "scopedep.rb"
 
-  def test_rake_returns_no_status_error_on_normal_exit
-    in_environment("PWD" => "test/data/statusreturn") do
-      rake "normal"
-      assert_status(0)
-    end
+    assert_match(/^PREPARE\nSCOPEDEP$/m, @out)
   end
 
   def test_comment_before_task_acts_like_desc
-    in_environment("PWD" => "test/data/comments") do
-      rake "-T"
-    end
+    rakefile_comments
+
+    rake "-T"
+
     refute_match(/comment for t1/, @out)
   end
 
   def test_comment_separated_from_task_by_blank_line_is_not_picked_up
-    Dir.chdir("test/data/comments") { rake("-T")}
-    assert_not_match("t2", @out)
+    rakefile_comments
+
+    rake "-T"
+
+    refute_match("t2", @out)
   end
 
   def test_comment_after_desc_is_ignored
-    Dir.chdir("test/data/comments") { rake("-T")}
+    rakefile_comments
+
+    rake "-T"
+
     assert_match("override comment for t3", @out)
   end
 
   def test_comment_before_desc_is_ignored
-    Dir.chdir("test/data/comments") { rake("-T")}
+    rakefile_comments
+
+    rake "-T"
+
     assert_match("override comment for t4", @out)
   end
 
   def test_correct_number_of_tasks_reported
-    Dir.chdir("test/data/comments") { rake("-T")}
+    rakefile_comments
+
+    rake "-T"
+
     assert_equal(2, @out.split(/\n/).grep(/t\d/).size)
   end
 
   def test_file_list_is_requirable_separately
-    ruby "-rrake/file_list", "-e 'puts Rake::FileList[\"a\"].size'"
+    ruby '-rrake/file_list', '-e', 'puts Rake::FileList["a"].size'
     assert_equal "1\n", @out
-    assert_equal 0, @status
   end
 
   private
 
-  def assert_not_match(pattern, string, comment="'#{pattern}' was found (incorrectly) in '#{string}.inspect")
-    assert_nil Regexp.new(pattern).match(string), comment
-  end
-
-  def remove_chaining_files
-    %w(play.scpt play.app base).each do |fn|
-      FileUtils.rm_f File.join("test/data/chains", fn)
-    end
-  end
-
-  def remove_namespace_files
-    %w(scopedep.rb).each do |fn|
-      FileUtils.rm_f File.join("test/data/namespace", fn)
-    end
-  end
-
   # Run a shell Ruby command with command line options (using the
-  # default test options). Output is captured in @out, @err and
-  # @status.
+  # default test options). Output is captured in @out and @err
   def ruby(*option_list)
     run_ruby(@ruby_options + option_list)
   end
 
   # Run a command line rake with the give rake options.  Default
   # command line ruby options are included.  Output is captured in
-  # @out, @err and @status.
+  # @out and @err
   def rake(*rake_options)
     run_ruby @ruby_options + [@rake_path] + rake_options
   end
 
   # Low level ruby command runner ...
   def run_ruby(option_list)
-    shell = Session::Shell.new
-    command = "#{RUBY_COMMAND} " + option_list.join(' ')
-    puts "COMMAND: [#{command}]" if @verbose
-    @out, @err = shell.execute command
-    @status = shell.exit_status
-    puts "STATUS:  [#{@status}]" if @verbose
+    puts "COMMAND: [#{RUBY} #{option_list.join ' '}]" if @verbose
+
+    inn, out, err = Open3.popen3(Gem.ruby, *option_list)
+    inn.close
+
+    @out = out.read
+    @err = err.read
+
     puts "OUTPUT:  [#{@out}]" if @verbose
     puts "ERROR:   [#{@err}]" if @verbose
     puts "PWD:     [#{Dir.pwd}]" if @verbose
-    shell.close
   end
 
-  def assert_status(expected_status=0)
-    assert_equal expected_status, @status
-  end
-end if defined?(Session)
+end