tap 0.7.9

data/test/file_task/config/batch.yml

@@ -0,0 +1,2 @@
+- one: one
+- two: two

data/test/file_task/config/configured.yml

@@ -0,0 +1 @@
+config: value

data/test/file_task_test.rb

@@ -0,0 +1,1041 @@
+require File.join(File.dirname(__FILE__), 'tap_test_helper')
+require 'tap/file_task'
+
+class FileTaskTest < Test::Unit::TestCase
+	acts_as_tap_test 
+	
+	attr_reader :t
+  
+	def setup
+	  super
+	  @t = Tap::FileTask.new
+	end
+	
+	def touch_file(path, content=nil)
+    FileUtils.mkdir_p(File.dirname(path))
+    if content
+      File.open(path, "w") {|f| f << content}
+    else
+      FileUtils.touch(path)
+    end
+  end
+  
+  def test_touch_file
+    non_existant_file = infer_filepath(:output, "non_existant_file.txt")
+    assert !File.exists?(non_existant_file)
+    touch_file(non_existant_file)
+    assert File.exists?(non_existant_file)
+    assert File.file?(non_existant_file)
+    assert_equal "", File.read(non_existant_file)
+    
+    non_existant_file = infer_filepath(:output, "non_existant_file2.txt")
+    assert !File.exists?(non_existant_file)
+    touch_file(non_existant_file, "content")
+    assert File.exists?(non_existant_file)
+    assert File.file?(non_existant_file)
+    assert_equal "content", File.read(non_existant_file)
+  end
+	
+	#
+	# dirname tests
+	#
+	
+	def test_dirname_returns_default_dirname_by_default
+	  assert_equal "tap/file_task", t.dirname
+	
+	  t = Tap::FileTask.new "batch"
+	  assert_equal 2, t.batch.size
+	  t1, t2 = t.batch
+	  assert_equal "batch_0", t1.dirname
+	  assert_equal "batch_1", t2.dirname
+	end
+	
+	def test_dirname_returns_dirname_if_set
+	  t.dirname = "name"
+	  assert_equal "name", t.dirname
+	end
+	
+	#
+	# inference tests
+	#
+	
+	def test_inference_sets_inference_block
+		block = lambda {}
+		t.inference(&block)
+		assert_equal block, t.inference_block
+	end
+	
+	def test_inference_can_only_be_set_once
+		t.inference {}
+		assert_raise(RuntimeError) { t.inference {} }
+		assert_raise(RuntimeError) { t.inference }
+	end
+	
+	#
+	# infer_filepath tests
+	#
+
+	def test_infer_filepath_passes_app_dir_dirname_and_path_to_block
+	  t.inference do |root, dir, path|
+	    [root, dir, path]
+	  end
+	  
+	  assert_equal "tap/file_task", t.dirname
+	  assert_equal [app[:dir], "tap/file_task", "path"], t.infer_filepath(:dir, "path")
+	end
+	
+	def test_infer_filepath_with_multiple_paths
+	  t.inference do |root, dir, *paths|
+	    [root, dir, paths]
+	  end
+	  assert_equal [app[:dir], "tap/file_task", ["path", "to", "file"]], t.infer_filepath(:dir, "path", "to", "file")
+	end
+	
+	def test_infer_filepath_with_multiple_paths_but_single_path_given
+	  t.inference do |root, dir, *paths|
+	    [root, dir, paths]
+	  end
+	  assert_equal [app[:dir], "tap/file_task", ["path"]], t.infer_filepath(:dir, "path")
+	  
+	  t.inference(true) do |root, dir, path_a, path_b|
+	    [root, dir, path_a, path_b]
+	  end
+	  assert_equal [app[:dir], "tap/file_task", "path", nil], t.infer_filepath(:dir, "path")
+	end
+	
+	def test_infer_filepath_with_single_path_but_multiple_paths_given
+	  t.inference do |root, dir, path|
+	    [root, dir, path]
+	  end
+	  assert_equal [app[:dir], "tap/file_task", "path"], t.infer_filepath(:dir, "path", "to", "file")
+	end
+	
+	def test_infer_filepath_constructs_path_using_app_filepath_when_inference_block_is_not_set
+	  assert_nil t.inference_block
+	  assert_equal(
+	    app.filepath(:dir, "tap/file_task", "path", "to", "file"),
+	    t.infer_filepath(:dir, "path", "to", "file"))
+	end
+
+  #
+  # backup_filepath test
+  #
+
+  def prepare_backup_filepath_with_output_and_timestamp
+    timestamp_format = "%Y%m%d"
+    timestamp = Time.now.strftime(timestamp_format)
+    
+    t.backup_dir = :output
+    t.backup_timestamp = timestamp_format
+    
+    timestamp
+  end
+
+  def test_backup_filepath_infers_filepath_using_backup_dir_and_timestamp
+    timestamp = prepare_backup_filepath_with_output_and_timestamp
+    
+    assert_equal(
+      app.filepath(:output, t.name, "file_#{timestamp}.txt"), 
+      t.backup_filepath("file.txt"))
+  end
+    
+  def test_backup_filepath_uses_inference_block
+    timestamp = prepare_backup_filepath_with_output_and_timestamp
+    
+    t.inference do |root, dir, path|
+	    [root, dir, path]
+	  end
+
+	  assert_equal(
+	    [app[:output], "tap/file_task", "file_#{timestamp}.txt"],
+	    t.backup_filepath("file.txt"))
+  end
+  
+  def test_backup_filepath_uses_path_relative_to_dirname_if_input_is_relative_to_dirname
+    timestamp = prepare_backup_filepath_with_output_and_timestamp
+    
+    t.inference do |root, dir, path|
+	    [root, dir, path]
+	  end
+	      
+    assert_equal("tap/file_task", t.dirname)
+    assert_equal(
+      [app[:output], t.name, "path/to/file_#{timestamp}.txt"], 
+      t.backup_filepath("folder/tap/file_task/path/to/file.txt"))
+  end
+  
+  def test_backup_filepath_uses_the_input_basename_if_input_is_not_relative_to_dirname
+    timestamp = prepare_backup_filepath_with_output_and_timestamp
+
+    t.inference do |root, dir, path|
+	    [root, dir, path]
+	  end
+	  
+    assert_equal(
+      [app[:output], t.name, "file_#{timestamp}.txt"], 
+      t.backup_filepath("path/to/file.txt"))
+  end
+  
+  def test_backup_filepath_does_not_mistake_files_as_folders_when_checking_if_input_is_relative_to_dirname
+    timestamp = prepare_backup_filepath_with_output_and_timestamp
+
+    t.inference do |root, dir, path|
+	    [root, dir, path]
+	  end
+	  
+    assert_equal(
+      [app[:output], t.name, "file_task_#{timestamp}.txt"], 
+      t.backup_filepath("folder/tap/file_task.txt"))
+  end
+  
+  #
+  # open tests
+  #
+  
+  def test_open_opens_each_file
+    FileUtils.mkdir_p(infer_filepath(:output))
+    
+    list = [0, 1].collect do |n| 
+      path = infer_filepath(:output, "#{n}.txt")
+      File.open(path, "w") {|f| f << n.to_s}
+      path
+    end
+    
+    t.open(list) do |files|
+      files.each_with_index do |file, n|
+        assert_equal File, file.class
+        assert_equal n.to_s, file.read
+      end
+    end    
+  end
+  
+  def test_open_opens_with_input_mode
+    FileUtils.mkdir_p(infer_filepath(:output))
+    
+    list = [0, 1].collect do |n| 
+      path = infer_filepath(:output, "#{n}.txt")
+      path
+    end
+    
+    t.open(list, "w") do |files|
+      files.each_with_index do |file, n|
+        assert_equal File, file.class
+        file << n.to_s
+      end
+    end  
+    
+    list.each_with_index do |file, n|
+      assert_equal n.to_s, File.read(file)
+    end  
+  end
+  
+  def test_open_returns_open_files_if_no_block_is_given
+    FileUtils.mkdir_p(infer_filepath(:output))
+    
+    list = [0, 1].collect do |n| 
+      path = infer_filepath(:output, "#{n}.txt")
+      File.open(path, "w") {|f| f << n.to_s}
+      path
+    end
+    
+    open_files = t.open(list)
+    open_files.each_with_index do |file, n|
+      assert_equal File, file.class
+      assert_equal n.to_s, file.read
+      file.close
+    end
+  end
+  
+	#
+	# uptodate tests
+	#
+
+	def uptodate_test_setup(output_str='')
+		of1 = ifs.filepath(:root, 'old_file_one.txt')
+		of2 = ifs.filepath(:root, 'old_file_two.txt')
+		
+		nf1 = tempfile('new_file_one.txt')
+		File.open(nf1, "w") {|file| file << output_str}
+		
+		nf2 = tempfile('new_file_two.txt')
+		File.open(nf2, "w") {|file| file << output_str}
+		
+		[of1, of2, nf1, nf2]
+	end
+	
+	def test_uptodate_test_setup
+		files = uptodate_test_setup
+		files.each { |file| assert File.exists?(file), file }
+
+		of1, of2, nf1, nf2 = files
+		assert FileUtils.uptodate?(nf1, of1)
+		assert FileUtils.uptodate?(nf2, of1)
+		assert FileUtils.uptodate?(nf1, of2)
+		assert FileUtils.uptodate?(nf2, of2)
+	end
+
+	def test_uptodate
+		of1, of2, nf1, nf2 = uptodate_test_setup
+		
+		non = ifs.filepath(:output, "non_existant_file.txt")
+    assert !File.exists?(non)
+    
+    assert t.uptodate?(nf1)
+		assert t.uptodate?(nf1, of1)
+		assert t.uptodate?(nf1, [of1, of2])
+		assert t.uptodate?(nf1, [of1, of2, non])
+		assert t.uptodate?([nf1, nf2], of1)
+    assert t.uptodate?([nf1, nf2], [of1, of2])
+    
+		assert !t.uptodate?(of1, nf1)
+		assert !t.uptodate?(of1, [nf1, nf2])
+		assert !t.uptodate?(non, nf1)
+		assert !t.uptodate?(non, of1)
+    assert !t.uptodate?([nf1, non], of1)
+    assert !t.uptodate?([nf1, non], [of1, of2])
+	end
+  
+  def test_uptodate_with_up_to_date_config_file
+    t = Tap::FileTask.new "configured"
+    
+    of1, of2, nf1, nf2 = uptodate_test_setup
+		
+		non = ifs.filepath(:output, "non_existant_file.txt")
+    assert !File.exists?(non)
+    
+    assert t.uptodate?(nf1)
+		assert t.uptodate?(nf1, of1)
+		assert t.uptodate?(nf1, [of1, of2])
+		assert t.uptodate?(nf1, [of1, of2, non])
+		assert t.uptodate?([nf1, nf2], of1)
+    assert t.uptodate?([nf1, nf2], [of1, of2])
+    
+		assert !t.uptodate?(of1, nf1)
+		assert !t.uptodate?(of1, [nf1, nf2])
+		assert !t.uptodate?(non, nf1)
+		assert !t.uptodate?(non, of1)
+    assert !t.uptodate?([nf1, non], of1)
+    assert !t.uptodate?([nf1, non], [of1, of2])
+  end
+  
+  def test_uptodate_with_out_of_date_config_file
+    filepath = ifs.filepath(:config, "configured-0.1.yml")
+    assert !File.exists?(filepath)
+    begin
+      of1, of2, nf1, nf2 = uptodate_test_setup
+      FileUtils.touch(filepath)
+      t = Tap::FileTask.new "configured-0.1"
+
+      assert !t.uptodate?(nf1)
+      assert !t.uptodate?(nf1, of1)
+      assert !t.uptodate?([nf1, nf2], [of1, of2])
+    rescue
+      raise $!
+    ensure
+      FileUtils.rm(filepath) if File.exists?(filepath)
+    end
+  end
+	
+	def test_uptodate_returns_false_when_force
+		of1, of2, nf1, nf2 = uptodate_test_setup
+		
+		assert t.uptodate?(nf1, of1)
+		with_options :force => true, :quiet => true do
+			assert app.options.force
+			assert !t.uptodate?(nf1, of1)
+		end
+	end
+	
+	#
+	# backup tests
+	#
+	
+	def backup_test_setup
+	  existing_file = infer_filepath(:output, "file.txt")
+	  backup_file = infer_filepath(:output, "backup.txt")
+	  
+    touch_file(existing_file, "existing content")
+    # assure backup_filepath will return backup_file 
+    t.inference {|root, dir, path| backup_file}	
+    
+    [existing_file, backup_file]  
+	end
+	
+	def test_backup_test_setup
+	  existing_file, backup_file = backup_test_setup
+	  
+	  assert File.exists?(existing_file)
+    assert !File.exists?(backup_file)
+    
+    assert_equal "existing content", File.read(existing_file)
+    assert_equal backup_file, t.backup_filepath(existing_file)
+	end
+	
+	def test_backup_copies_filepath_to_backup_filepath
+    existing_file, backup_file = backup_test_setup
+    
+    t.backup(existing_file)
+    
+    assert File.exists?(existing_file)
+    assert File.exists?(backup_file)
+    assert FileUtils.compare_file(existing_file, backup_file)
+	end
+	
+	def test_backup_moves_filepath_to_backup_filepath_unless_copy_is_true
+	  existing_file, backup_file = backup_test_setup
+    
+    t.backup(existing_file, false)
+    
+    assert !File.exists?(existing_file)
+    assert File.exists?(backup_file)
+    assert_equal "existing content", File.read(backup_file)
+	end
+	
+	def test_backup_registers_expanded_filepath_and_backup_filepath_in_backed_up_files
+	  existing_file, backup_file = backup_test_setup
+	  
+	  assert_not_equal existing_file, File.expand_path(existing_file)
+	  
+    assert_equal({}, t.backed_up_files)
+    t.backup(existing_file)
+    assert_equal({File.expand_path(existing_file) => File.expand_path(backup_file)}, t.backed_up_files)
+	end
+	
+  def test_backup_does_nothing_if_filepath_does_not_exist
+ 	  existing_file, backup_file = backup_test_setup
+	  FileUtils.rm(existing_file)
+	  
+	  assert !File.exists?(existing_file)
+	  assert !File.exists?(backup_file)
+    assert_equal({}, t.backed_up_files)
+    
+    t.backup(existing_file)
+    
+	  assert !File.exists?(existing_file)
+	  assert !File.exists?(backup_file)
+    assert_equal({}, t.backed_up_files)  
+  end
+  
+  def test_backup_acts_on_list_and_returns_backup_files
+	  existing_file0 = infer_filepath(:output, "file0.txt")
+	  existing_file1 = infer_filepath(:output, "file1.txt")
+	  backup_file0 = infer_filepath(:output, "backup0.txt")
+	  backup_file1 = infer_filepath(:output, "backup1.txt")
+	  
+    touch_file(existing_file0)
+    touch_file(existing_file1)
+    t.inference do |root, dir, path| 
+      path =~ /file0/ ? backup_file0 : backup_file1
+    end
+    
+    assert !File.exists?(backup_file0)
+    assert !File.exists?(backup_file1)
+    
+    assert_equal [File.expand_path(backup_file0), File.expand_path(backup_file1)], t.backup([existing_file0, existing_file1])
+   
+    assert File.exists?(backup_file0)
+    assert File.exists?(backup_file1)
+  end
+  
+  def test_backup_raises_error_if_backup_for_file_already_exists
+    existing_file, backup_file = backup_test_setup
+    t.backup(existing_file)
+    
+    assert_raise(RuntimeError) { t.backup(existing_file) }
+  end
+  
+  #
+  # restore tests
+  #
+  
+  def test_restore_restores_backed_up_file_to_original_location_as_listed_in_backed_up_files
+    original_file = File.expand_path(infer_filepath(:output, 'original/file.txt'))
+    backup_file = File.expand_path(infer_filepath(:output, 'backup/file.txt'))
+
+    FileUtils.mkdir_p( File.dirname(original_file) )
+    touch_file(backup_file)
+    
+    assert File.exists?(File.dirname(original_file))
+    assert !File.exists?(original_file)
+    assert File.exists?(backup_file)
+    
+    t.backed_up_files[original_file] = backup_file
+    t.restore(original_file)
+    
+    assert File.exists?(original_file)
+    assert !File.exists?(backup_file)
+  end
+  
+  def test_restore_creates_dirs_as_needed_to_restore_file
+    original_file = File.expand_path(infer_filepath(:output, 'original/file.txt'))
+    backup_file = File.expand_path(infer_filepath(:output, 'backup/file.txt'))
+
+    touch_file(backup_file)
+    
+    assert !File.exists?(File.dirname(original_file))
+    assert !File.exists?(original_file)
+    assert File.exists?(backup_file)
+    
+    t.backed_up_files[original_file] = backup_file
+    t.restore(original_file)
+    
+    assert File.exists?(original_file)
+    assert !File.exists?(backup_file)
+  end
+  
+  def test_restore_raises_error_if_the_input_file_is_not_backed_up
+    assert t.backed_up_files.empty?
+    assert_raise(RuntimeError) { t.restore("original_file") }
+  end
+  
+  def test_restore_removes_backup_dir_using_rmdir
+    original_file = File.expand_path(infer_filepath(:output, 'original/file.txt'))
+    backup_file = File.expand_path(infer_filepath(:output, 'backup/file.txt'))
+    backup_dir = File.dirname(backup_file)
+    
+    t.mkdir(backup_file)
+    assert File.exists?(backup_dir)
+    
+    touch_file(backup_file)
+  
+    t.backed_up_files[original_file] = backup_file
+    t.restore(original_file)
+    
+    assert !File.exists?(backup_dir)
+  end
+  
+  def test_restore_acts_on_list_and_returns_restored_files
+	  existing_file0 = File.expand_path(infer_filepath(:output, "file0.txt"))
+	  existing_file1 = File.expand_path(infer_filepath(:output, "file1.txt"))
+	  backup_file0 = File.expand_path(infer_filepath(:output, "backup0.txt"))
+	  backup_file1 = File.expand_path(infer_filepath(:output, "backup1.txt"))
+	  
+    touch_file(backup_file0)
+    touch_file(backup_file1)
+    
+    t.backed_up_files[existing_file0] = backup_file0
+    t.backed_up_files[existing_file1] = backup_file1
+    
+    assert !File.exists?(existing_file0)
+    assert !File.exists?(existing_file1)
+    
+    assert_equal [existing_file0, existing_file1], t.restore([existing_file0, existing_file1])
+    
+    assert File.exists?(existing_file0)
+    assert File.exists?(existing_file1)
+  end
+  
+	#
+	# mkdir tests
+	#
+	
+	def test_mkdir_creates_dir_if_it_does_not_exist
+	  dir = infer_filepath(:output, 'path/to/non_existant_folder')
+	  FileUtils.mkdir_p(File.dirname(dir))
+  	assert !File.exists?(dir)
+  	
+  	t.mkdir(dir)
+  	assert File.exists?(dir)
+	end
+	
+	def test_mkdir_creates_parent_dirs_if_they_do_not_exist
+	  dir = infer_filepath(:output, 'path/to/non_existant_folder')
+  	assert !File.exists?(infer_filepath(:output))
+  	
+  	t.mkdir(dir)
+  	assert File.exists?(dir)
+	end
+	
+	def test_mkdir_registers_expanded_dir_and_all_non_existing_parent_dirs_in_made_files
+	  dir = infer_filepath(:output, 'path/to/non_existant_folder')
+	  assert_equal [], t.made_files
+	  assert_not_equal dir, File.expand_path(dir)
+	  
+	  t.mkdir(dir)
+	  
+	  expected = [
+	    infer_root,
+	    infer_filepath(:output),
+	    infer_filepath(:output, 'path'),
+	    infer_filepath(:output, 'path/to'),
+	    infer_filepath(:output, 'path/to/non_existant_folder')
+	  ].collect do |dir|
+	    File.expand_path(dir)
+	  end
+	    
+	  assert_equal expected, t.made_files
+	end
+	
+	def test_mkdir_acts_on_and_returns_list
+    dir = infer_filepath(:output, 'path')
+    another = infer_filepath(:output, 'another')
+    
+    assert !File.exists?(dir)
+    assert !File.exists?(another)
+    
+    assert_equal [dir, another], t.mkdir([dir, another])
+    
+    assert File.exists?(dir)
+    assert File.exists?(another)
+  end
+  
+  #
+  # rmdir tests
+  #
+  
+  def test_rmdir_removes_dir_if_made_by_the_task
+	  dir = infer_filepath(:output, 'path/to/non_existant_folder')
+	  existing_dir = infer_filepath(:output, 'path/to')
+	  
+	  FileUtils.mkdir_p(existing_dir)
+	  assert File.exists?(existing_dir)
+	  assert !File.exists?(dir)
+	  
+	  t.mkdir(dir)
+  	assert File.exists?(dir)
+  	
+  	t.rmdir(dir)
+  	assert File.exists?(existing_dir)
+  	assert !File.exists?(dir)
+	end
+	
+	def test_rmdir_removes_parent_dirs_if_made_by_the_task
+	  dir = infer_filepath(:output, 'path/to/non/existant/folder')
+	  root_parent_dir = infer_filepath(:output, 'path/to')
+	  existing_dir = infer_filepath(:output, 'path')
+	  
+	  FileUtils.mkdir_p(existing_dir)
+	  assert File.exists?(existing_dir)
+	  assert !File.exists?(root_parent_dir)
+	  
+	  t.mkdir(dir)
+  	assert File.exists?(dir)
+  	
+  	t.rmdir(dir)
+  	assert File.exists?(existing_dir)
+  	assert !File.exists?(root_parent_dir)
+	end
+
+  def test_rmdir_does_not_remove_if_dir_was_not_made_by_task
+	  dir = infer_filepath(:output, 'path/to/non_existant_folder')
+
+	  FileUtils.mkdir_p(dir)
+    assert File.exists?(dir)
+    
+  	t.rmdir(dir)
+  	assert File.exists?(dir)
+	end
+
+	def test_rmdir_does_not_remove_if_folder_is_not_empty
+	  dir = infer_filepath(:output, 'path/to/folder')
+	  not_empty_dir = infer_filepath(:output, 'path/to')
+
+	  t.mkdir(dir)
+  	assert File.exists?(dir)
+  	
+  	touch_file File.join(not_empty_dir, "file.txt")
+  	
+  	t.rmdir(dir)
+  	assert File.exists?(not_empty_dir)
+  	assert !File.exists?(dir)
+	end
+	
+	def test_rmdir_checks_for_hidden_files_as_well_as_regular_files
+	  dir = infer_filepath(:output, 'path/to/folder')
+	  not_empty_dir = infer_filepath(:output, 'path/to')
+
+	  t.mkdir(dir)
+  	assert File.exists?(dir)
+  	
+  	touch_file File.join(not_empty_dir, ".hidden_file")
+  	
+  	t.rmdir(dir)
+  	assert File.exists?(not_empty_dir)
+  	assert !File.exists?(dir)
+	end
+
+	def test_rmdir_clears_made_files_of_removed_dirs
+	  dir = infer_filepath(:output, 'path/to/folder')
+
+	  FileUtils.mkdir_p(infer_filepath(:output))
+	  assert_equal [], t.made_files
+  
+	  t.mkdir(dir)
+  	assert_equal [
+  	  File.expand_path(infer_filepath(:output, 'path')),
+  	  File.expand_path(infer_filepath(:output, 'path/to')),
+  	  File.expand_path(infer_filepath(:output, 'path/to/folder'))], t.made_files
+  	
+  	# touch a file so the 'path' folder isn't removed
+  	touch_file infer_filepath(:output, 'path/file.txt')
+  	
+  	t.rmdir(dir)
+  	assert_equal [
+  	  File.expand_path(infer_filepath(:output, 'path'))], t.made_files
+	end
+
+	def test_rmdir_acts_on_and_returns_expanded_list_of_removed_dirs
+    dir = infer_filepath(:output, 'path')
+    another = infer_filepath(:output, 'another')
+    not_removed = infer_filepath(:output, 'not')
+    removed = infer_filepath(:output, 'not/removed')
+    
+    t.mkdir([dir, another, not_removed, removed])
+    # touch a file so the not_removed folder isn't removed
+  	touch_file infer_filepath(:output, 'not/file.txt')
+  	
+  	expected = [dir, another, removed].collect {|d| File.expand_path(d)}
+    assert_equal expected, t.rmdir([dir, another, not_removed, removed])
+  end
+
+  #
+  # make tests
+  #
+  
+  def test_make_acts_on_and_returns_list
+    filepath = "file.txt"
+    another = "another.txt"
+    assert_equal [filepath, another], t.make([filepath, another])
+  end
+  
+  def test_make_yields_list_if_block_given
+    was_in_make = false
+    t.make("file.txt") do |list|
+      was_in_make = true
+      assert_equal ["file.txt"], list
+    end
+    assert was_in_make
+  end
+  
+  def test_make_backs_up_existing_files_and_creates_non_existant_dirs
+    existing_file = infer_filepath(:output, "path/to/existing/file.txt")
+    non_existant_file = infer_filepath(:output, "path/to/non/existant/file.txt")
+    touch_file(existing_file, "existing content")
+    
+    # be sure inference leads files to an output dir, for cleanup
+    removal_path = infer_filepath(:output, 'removal')
+    t.inference {|root, dir, path| removal_path}
+
+    assert File.exists?(existing_file)
+    assert !File.exists?(non_existant_file)
+
+    files = [existing_file, non_existant_file]
+    t.make(files) 
+    
+    # check neither of the files exist at this point
+    # and the parent dirs all exist
+    files.each do |file|
+      assert !File.exists?(file)
+      assert File.exists?(File.dirname(file))
+    end
+    
+    # check the existing file was backed up
+    assert_equal({File.expand_path(existing_file) => File.expand_path(removal_path)}, t.backed_up_files)
+    assert_equal "existing content", File.read(removal_path)
+  end
+  
+  def test_make_adds_list_to_made_files
+    existing_file = infer_filepath(:output, "path/to/existing/file.txt")
+    non_existant_file = infer_filepath(:output, "path/to/non/existant/file.txt")
+    touch_file(existing_file)
+    
+    # be sure inference leads files to an output dir, for cleanup
+    removal_path = infer_filepath(:output, 'removal')
+    t.inference {|root, dir, path| File.join(removal_path, path) }
+
+    assert_equal([], t.made_files)
+    assert File.exists?(existing_file)
+    assert !File.exists?(non_existant_file)
+    assert !File.exists?(removal_path)
+    
+    files = [existing_file, non_existant_file]
+    t.make(files) 
+    
+	  expected = [
+	    removal_path,  # added by backup of existing_file
+	    existing_file, # added by make
+	    infer_filepath(:output, 'path/to/non'), # added by mkdir
+	    infer_filepath(:output, 'path/to/non/existant'), # added by mkdir
+	    non_existant_file # added by make
+	  ].collect do |dir|
+	    File.expand_path(dir)
+	  end
+	  
+	  assert_equal expected, t.made_files
+  end
+  
+  #
+  # rm tests
+  #
+  
+  def test_rm_removes_file_and_parent_dirs_if_made_by_the_task
+	  file = infer_filepath(:output, 'path/to/file.txt')
+	  parent_dir = infer_filepath(:output, 'path/to')
+	  existing_dir = infer_filepath(:output, 'path')
+	  FileUtils.mkdir_p existing_dir
+	  
+	  assert File.exists?(existing_dir)
+	  assert !File.exists?(file)
+	  
+	  t.make file
+	  touch_file(file)
+	  assert File.exists?(file)
+	  
+	  t.rm(file)
+	  assert File.exists?(existing_dir)
+	  assert !File.exists?(parent_dir)
+  	assert !File.exists?(file)
+	end
+	
+	def test_rm_removes_parent_dirs_even_if_file_does_not_exist
+	  file = infer_filepath(:output, 'path/to/file.txt')
+	  parent_dir = infer_filepath(:output, 'path/to')
+	  existing_dir = infer_filepath(:output, 'path')
+	  FileUtils.mkdir_p existing_dir
+	  
+	  assert File.exists?(existing_dir)
+	  assert !File.exists?(file)
+	  
+	  t.make file
+	  assert !File.exists?(file)
+	  
+	  t.rm(file)
+	  assert File.exists?(existing_dir)
+	  assert !File.exists?(parent_dir)
+	end
+	
+	def test_rm_does_not_remove_file_if_not_made_by_the_task
+	  file = infer_filepath(:output, 'path/to/file.txt')
+
+	  touch_file(file)
+	  assert File.exists?(file)
+	  
+	  t.rm(file)
+  	assert File.exists?(file)
+	end
+	
+	def test_rm_clears_made_files_of_removed_files
+	  file0 = infer_filepath(:output, 'file0.txt')
+	  file1 = infer_filepath(:output, 'file1.txt')
+
+	  FileUtils.mkdir_p(infer_filepath(:output))
+	  assert_equal [], t.made_files
+  
+	  t.make([file0,file1])
+  	assert_equal [
+  	  File.expand_path(infer_filepath(:output, 'file0.txt')),
+  	  File.expand_path(infer_filepath(:output, 'file1.txt'))], t.made_files
+  	
+  	t.rm(file0)
+  	assert_equal [
+  	  File.expand_path(infer_filepath(:output, 'file1.txt'))], t.made_files
+	end
+	
+	def test_rm_acts_on_and_returns_expanded_list_of_removed_files_and_dirs
+    file = infer_filepath(:output, 'file.txt')
+    another = infer_filepath(:output, 'another.txt')
+    not_removed = infer_filepath(:output, 'not')
+    removed = infer_filepath(:output, 'not/removed.txt')
+    
+    t.make([file, another, removed])
+    # touch a file so the not_removed folder isn't removed
+  	touch_file infer_filepath(:output, 'not/file.txt')
+  	
+  	expected = [file, another, removed].collect {|f| File.expand_path(f)}
+    assert_equal expected, t.rm([file, another, removed])
+  end
+  
+  #
+  # process tests
+  #
+  
+  def setup_process_test(&block)
+    existing_file = infer_filepath(:output, "path/to/existing/file.txt")
+    non_existant_dir = infer_filepath(:output, "path/to/non/existing")
+    non_existant_file = File.join(non_existant_dir, "file.txt")
+    backup_file = infer_filepath(:output, "backup/file.txt")
+    
+    touch_file(existing_file, "original content")
+	  @t = Tap::FileTask.new do |task, input|
+	    task.make([existing_file, non_existant_file]) 
+
+      block.call if block_given?
+	  end
+    # inference leads to the backup_file
+    @t.inference do |root, dir, path|
+	    backup_file
+	  end
+	  
+	  [existing_file, backup_file, non_existant_dir, non_existant_file]
+  end
+  
+  def test_setup_process_test
+    existing_file, backup_file, non_existant_dir, non_existant_file = setup_process_test do 
+      assert !File.exists?(non_existant_file)
+      assert File.exists?(non_existant_dir)
+      assert File.exists?(backup_file)
+      assert_equal "original content", File.read(backup_file)
+    end
+    t.execute(nil)
+  end
+  
+  def test_process_restores_backups_and_removes_made_files_on_error
+    was_in_process = false
+    existing_file, backup_file, non_existant_dir, non_existant_file = setup_process_test do 
+      was_in_process = true
+      raise "error"
+    end
+
+	  assert_raise(RuntimeError) { t.execute(nil)  }
+
+    # check the existing file was restored
+    assert was_in_process
+    assert File.exists?(existing_file)
+    assert !File.exists?(non_existant_dir)
+    assert !File.exists?(backup_file)
+    assert_equal "original content", File.read(existing_file)
+  end
+  
+  def test_process_does_not_restores_backups_if_restore_on_error_is_false
+    was_in_process = false
+    existing_file, backup_file, non_existant_dir, non_existant_file = setup_process_test do
+      was_in_process = true
+      raise "error"
+    end
+
+	  t.restore_on_error = false
+	  assert_raise(RuntimeError) { t.execute(nil)  }
+
+    # check the existing file was NOT restored
+    assert was_in_process
+    assert !File.exists?(existing_file)
+    assert File.exists?(non_existant_dir)
+    assert File.exists?(backup_file)
+    assert_equal "original content", File.read(backup_file)
+  end
+  
+  def test_process_removes_backed_up_files_if_remove_backed_up_files_is_true
+    was_in_process = false
+    existing_file, backup_file, non_existant_dir, non_existant_file = setup_process_test do
+      was_in_process = true
+      touch_file(existing_file, "new content")
+    end
+
+	  t.remove_backed_up_files = true
+	  t.execute(nil)
+
+    # check the backup file was removed and that
+    # there was no restore (no error was raised)
+    assert was_in_process
+    assert File.exists?(existing_file)
+    assert_equal "new content", File.read(existing_file)
+    assert !File.exists?(backup_file)
+    assert !File.exists?(File.dirname(backup_file))
+  end
+  
+  def test_process_restores_backups_on_error_even_if_remove_backed_up_files_is_true
+    was_in_process = false
+    existing_file, backup_file, non_existant_dir, non_existant_file = setup_process_test do
+      was_in_process = true
+      touch_file(existing_file, "new content")
+      raise "error"
+    end
+  
+	  t.remove_backed_up_files = true
+	  assert_raise(RuntimeError) { t.execute(nil) }
+
+    # check the existing file was restored and
+    # backup file was removed
+    assert was_in_process
+    assert File.exists?(existing_file)
+    assert_equal "original content", File.read(existing_file)
+    assert !File.exists?(backup_file)
+    assert !File.exists?(File.dirname(backup_file))
+  end
+  
+  #
+  # test process with multiple files
+  #
+  
+  def setup_multiple_file_process_test(&block)
+    existing_files = [0,1].collect do |n|
+      path = infer_filepath(:output, "path/to/existing/file#{n}.txt")
+      touch_file path, n.to_s
+      path
+    end
+    
+    non_existant_files =  [0,1].collect do |n|
+      infer_filepath(:output, "path/to/non/existing/file#{n}.txt")
+    end
+    
+    @t = Tap::FileTask.new do |task, input|
+	    task.make(existing_files + non_existant_files) 
+	    block.call if block_given?
+	  end
+    # inference leads to an output_dir
+    @t.inference do |root, dir, path|
+	    infer_filepath(:output, 'backup', path)
+	  end
+	  
+	  [existing_files, non_existant_files]
+  end
+  
+  def test_setup_multiple_file_process_test
+    existing_files, non_existant_files = setup_multiple_file_process_test do 
+      (existing_files + existing_files).each do |file|
+	      assert !File.exists?(file)
+	      assert File.exists?(File.dirname(file))
+	    end
+    end
+    t.execute(nil)
+  end
+  
+  def test_process_restore_and_removal_with_multiple_files
+    was_in_process = false
+    existing_files, non_existant_files = setup_multiple_file_process_test do
+      was_in_process = true
+	    (existing_files + non_existant_files) .each do |file|
+	      touch_file file, "new content"
+	    end
+	    raise "error"
+	  end
+
+	  assert !File.exists?(infer_filepath(:output, 'backup'))
+	  assert_raise(RuntimeError) { t.execute(nil) }
+
+    # check existing files were restored, made files and backups removed.
+    assert was_in_process
+    existing_files.each_with_index do |existing_file, n|
+     assert File.exists?(existing_file)
+     assert_equal n.to_s, File.read(existing_file)
+    end
+    non_existant_files.each do |non_existing_file|
+      assert !File.exists?(non_existing_file)
+    end
+    assert !File.exists?(infer_filepath(:output, 'backup'))
+  end
+  
+  def test_process_remove_backed_up_files_with_multiple_files
+    was_in_process = false
+    existing_files, non_existant_files = setup_multiple_file_process_test do
+      was_in_process = true
+	    (existing_files + non_existant_files) .each do |file|
+	      touch_file file, "new content"
+	    end
+	  end
+
+	  assert !File.exists?(infer_filepath(:output, 'backup'))
+	  
+	  t.remove_backed_up_files = true
+	  t.execute(nil)
+
+    # check existing files were restored, made files and backups removed.
+    assert was_in_process
+    (existing_files + non_existant_files).each do |file|
+     assert File.exists?(file)
+     assert_equal "new content", File.read(file)
+    end
+    assert !File.exists?(infer_filepath(:output, 'backup'))
+  end
+
+end