rant 0.3.0

data/test/test_filetask.rb

@@ -0,0 +1,57 @@
+
+require 'test/unit'
+require 'rant/rantlib'
+
+$test_filetask_file = File.expand_path(__FILE__)
+
+class TestFileTask < Test::Unit::TestCase
+    def setup
+    end
+    def teardown
+    end
+
+    def test_needed_non_existent
+	run = false
+	t = Rant::FileTask.new(nil, "non_existent") { run = true }
+	assert(t.needed?,
+	    "`non_existent' doesn't exist, so filetask is needed")
+	assert(!run,
+	    "only FileTask#needed? was called, which shouldn't run task block")
+    end
+    def test_needed_no_dep
+	run = false
+	t = Rant.file $test_filetask_file do
+	    run = true
+	end
+	assert(!t.needed?,
+	    "file exists and has no prerequisite, so needed? should return false")
+	assert(!run)
+    end
+    def test_single_dep
+	tr = false
+	t = Rant.task :t do
+	    tr = true
+	end
+	run = false
+	f = Rant.file "testfile" => :t do
+	    run = true
+	end
+	f.invoke
+	assert(tr)
+	assert(run)
+    end
+    def test_prerequisites
+	Rant.file "a" do
+	    true
+	end
+	Rant.file "b" do
+	    true
+	end
+	f = Rant.file "c" => %w(a b) do |t|
+	    assert_equal(t.prerequisites, %w(a b),
+		"prerequisites should always be an array of _strings_")
+	    true
+	end
+	f.invoke
+    end
+end

data/test/test_lighttask.rb

@@ -0,0 +1,49 @@
+
+require 'test/unit'
+require 'rant/rantlib'
+
+
+class TestLightTask < Test::Unit::TestCase
+    def setup
+	@app = Rant::RantApp.new %w()
+    end
+    def teardown
+    end
+    # shortcut for Rant::LightTask.new
+    def lt(*args, &block)
+	Rant::LightTask.new(*[@app, args].flatten, &block)
+    end
+    def test_init
+	t = lt :tinit
+	assert(t.needed?,
+	    "needed? should be true after creation without " +
+	    "`needed' block")
+	assert(!t.done?)
+	assert_equal(t.name, "tinit",
+	    "task name should always be a string, despite creation with symbol")
+    end
+    def test_with_blocks
+	run = false
+	nr = false
+	t = lt :with_blocks do |a|
+	    a.needed {
+		nr = true
+	    }
+	    a.act do |l|
+		assert_equal(l, t,
+		    "act block should get the LightTask as argument")
+		run = true
+	    end
+	end
+	assert(t.needed?,
+	    "needed block returns true")
+	assert(nr,
+	    "`needed' block should have been run")
+	assert(t.invoke,
+	    "invoke should return true because task was needed")
+	assert(run,
+	    "task should have been run")
+	assert(!t.needed?,
+	    "task shouldn't be needed? after first run")
+    end
+end

data/test/test_metatask.rb

@@ -0,0 +1,29 @@
+
+require 'test/unit'
+require 'rant/rantlib'
+require 'tutil'
+
+class TestMetaTask < Test::Unit::TestCase
+    def setup
+	@app = Rant::RantApp.new %w()
+    end
+    def teardown
+    end
+    def test_with_single_task
+	run = false
+	t = @app.task :t do run = true end
+	mt = MetaTask.for_task t
+	assert_equal(t.name, mt.name,
+	    "MetaTask should have name of contained task(s).")
+	if t.needed?
+	    assert(mt.needed?,
+		"MetaTask should be needed? if only contained task is needed?")
+	    mt.invoke
+	    assert(run,
+		"only contained task was needed?, so it should get invoked")
+	else
+	    assert(!mt.needed?,
+		"MetaTask should return false from needed? because the only contained task does also.")
+	end
+    end
+end

data/test/test_rant_interface.rb

@@ -0,0 +1,65 @@
+
+require 'test/unit'
+require 'rant'
+require 'tutil'
+
+$testDir ||= File.expand_path(File.dirname(__FILE__))
+
+class TestRantInterface < Test::Unit::TestCase
+    def setup
+	# Ensure we run in test directory.
+	Dir.chdir($testDir) unless Dir.pwd == $testDir
+    end
+    def teardown
+    end
+    def test_cmd_targets
+	@app = RantApp.new("-f non_existent", "target", "-aforced_target")
+	op = capture_stderr {
+	    assert_equal(@app.run, 1,
+		"Rant should fail because there is no such Rantfile.")
+	}
+	assert(op =~ /\[ERROR\]/,
+	    "rant should print error message if -f RANTFILE not found")
+	assert_equal(@app.cmd_targets.size, 2,
+	    "there were to targets given on commandline")
+	assert(@app.cmd_targets.include?("target"))
+	assert(@app.cmd_targets.include?("forced_target"))
+	assert(@app.cmd_targets.first == "forced_target",
+	    "forced_target should run first")
+    end
+    def test_envvar_on_cmdline
+	@app = RantApp.new("VAR=VAL")
+	assert_equal(@app.run, 0)
+	assert_equal(ENV["VAR"], "VAL",
+	    "rant should set arguments of form VAR=VAL in ENV")
+    end
+    def test_envvar_on_cmdline_lc
+	@app = RantApp.new("var2=val2")
+	assert_equal(@app.run, 0)
+	assert_equal(ENV["var2"], "val2",
+	    "rant should set arguments of form var2=val2 in ENV")
+    end
+    def test_opt_targets
+	@app = RantApp.new("--tasks")
+	@app.desc 'This is a "public" target.'
+	@app.task :public_task
+	@app.task :private_task
+	op = capture_stdout { 
+	    assert_equal(@app.run, 0)
+	}
+	assert(op =~ /\bpublic_task\b/,
+	    "rant -T output should contain name of described task")
+	assert(op !~ /private_task/,
+	    "rant -T output shouldn't contain name of not-described task")
+    end
+    def test_opt_help
+	op = capture_stdout {
+	    assert_equal(Rant.run("--help"), 0,
+		"rant --help should return 0")
+	}
+	assert(!op.empty?,
+	    "rant --help should write to STDOUT")
+	assert(op.split("\n").size > 15,
+	    "rant --help should print at least 16 lines to STDOUT")
+    end
+end

data/test/test_sys.rb

@@ -0,0 +1,61 @@
+
+require 'test/unit'
+require 'rant/rantlib'
+require 'tutil'
+
+$testDir ||= File.expand_path(File.dirname(__FILE__))
+
+class TestFileUtils < Test::Unit::TestCase
+    include Rant::Sys
+
+    def setup
+	# Ensure we run in test directory.
+	Dir.chdir($testDir) unless Dir.pwd == $testDir
+    end
+    def teardown
+    end
+
+    def test_ruby
+	op = capture_stdout do
+	    ruby('-e ""') { |succ, stat|
+		assert(succ)
+		assert_equal(stat, 0)
+	    }
+	end
+	assert(op =~ /\-e/i,
+	    "Sys should print command with arguments to $stdout")
+    end
+    def test_split_path
+	pl = split_path("/home/stefan")
+	assert_equal(pl.size, 3,
+	    "/home/stefan should get split into 3 parts")
+	assert_equal(pl[0], "/")
+	assert_equal(pl[1], "home")
+	assert_equal(pl[2], "stefan")
+	pl = split_path("../")
+	assert_equal(pl.size, 1,
+	    '../ should be "split" into one element')
+	assert_equal(pl[0], "..")
+    end
+    # perhaps this test should go into a seperate file
+    def test_toplevel
+	assert_match(/\btd\b/, run_rant("-ftoplevel.rf"),
+	    "Sys module should print commands to stdout")
+	assert_equal(0, $?,
+	    "rant -ftoplevel.rf in test/ should be successfull")
+    ensure
+	File.delete "td" if File.exist? "td"
+    end
+    # ...ditto
+    def test_name_error
+	File.open("name_error.rf", "w") { |f|
+	    f << "no_var_no_method\n"
+	}
+	out, err = capture_std do
+	    assert_equal(1, Rant.run("-fname_error.rf"))
+	end
+	assert_match(/Name\s*Error/i, err.split("\n").first)
+    ensure
+	File.delete "name_error.rf" if File.exist? "name_error.rf"
+    end
+end

data/test/test_task.rb

@@ -0,0 +1,115 @@
+
+require 'test/unit'
+require 'rant/rantlib'
+
+$-w = true
+
+class TestTask < Test::Unit::TestCase
+    def setup
+    end
+    def teardown
+    end
+
+    def test_version
+	assert(Rant::VERSION.length >= 5)
+    end
+
+    def test_needed
+	run = false
+	t = Rant::Task.new(nil, :non_existent) { run = true }
+	assert(t.needed?,
+	    "Rant::Task should always be 'needed?' before first invocation")
+	assert(!run,
+	    "Rant::Task shouldn't get run when 'needed?' is called")
+    end
+
+    def test_invoke
+	run = false
+	block = lambda { run = true }
+	task = Rant::Task.new(nil, :test_run, &block)
+	task.invoke
+	assert(run, "block should have been executed")
+	assert(task.done?, "task is done")
+	assert(!task.needed?,
+	    "task is done, so 'needed?' should return false")
+    end
+
+    def test_fail
+	block = lambda { |t| t.fail "this task abortet itself" }
+	task = Rant::Task.new(nil, :test_fail, &block)
+	assert_raise(Rant::TaskFail,
+	    "run should throw Rant::TaskFail if block raises Exception") {
+	    task.invoke
+	}
+	assert(task.fail?)
+	assert(task.run?, "although task failed, it was ran")
+    end
+
+    def test_dependant
+	r1 = r2 = false
+	t1 = Rant::Task.new(nil, :t1) { r1 = true }
+	t2 = Rant::Task.new(nil, :t2) { r2 = true }
+	t1 << t2
+	t1.invoke
+	assert(r1)
+	assert(r2, "t1 depends on t2, so t2 should have been run")
+	assert(t1.done?)
+	assert(t2.done?)
+	assert(!t1.needed?)
+	assert(!t2.needed?)
+    end
+
+    def test_dependance_fails
+	t1 = Rant::Task.new(nil, :t1) { true }
+	t2 = Rant::Task.new(nil, :t2) { |t| t.fail }
+	t1 << t2
+	assert_raise(Rant::TaskFail,
+	    "dependency t2 failed, so t1 should fail too") {
+	    t1.invoke
+	}
+	assert(t1.fail?,
+	    "fail flag should be set for task if dependency fails")
+	assert(t2.fail?,
+	    "fail flag should be set for task if it fails")
+    end
+
+    def test_task
+	run = false
+	t = Rant.task :t do |t|
+	    run = true
+	end
+	t.invoke
+	assert(run)
+    end
+
+    def test_dep_on_self
+	run = false
+	t = Rant.task :t => "t" do |t|
+	    run = true
+	end
+	th = Thread.new { t.invoke }
+	# shouldn't take half a second...
+	assert_equal(th.join(0.5), th,
+	    "task should remove dependency on itself")
+	assert(run,
+	    "task should get run despite dependency on itself")
+    end
+    def test_dep_on_self_in_deplist
+	rl = []
+	t1 = Rant.task :t1 do |t|
+	    rl << t.name
+	end
+	t2 = Rant.task :t2 do |t|
+	    rl << t.name
+	end
+	t3 = Rant.task :t3 => [:t1, :t3, :t2] do |t|
+	    rl << t.name
+	end
+	th = Thread.new { t3.invoke }
+	# shouldn't take half a second...
+	assert_equal(th.join(0.5), th,
+	    "task should remove dependency on itself from dependency list")
+	assert_equal(rl, %w(t1 t2 t3),
+	    "t3 was run and depends on [t1, t2] => run order: t1 t2 t3")
+    end
+end

data/test/toplevel.rf

@@ -0,0 +1,11 @@
+
+require 'fileutils'
+include Sys
+
+def tf fn
+    touch fn
+end
+
+file :td do
+    tf "td"
+end

data/test/ts_all.rb

@@ -0,0 +1,4 @@
+
+# assumes to be run in the test/ directory of the Rant distribution
+
+Dir["**/test_*.rb"].each { |t| require t }

data/test/tutil.rb

@@ -0,0 +1,95 @@
+
+# This file contains methods that aid in testing Rant.
+
+RANT_BIN = File.expand_path(
+    File.join(File.dirname(__FILE__), "..", "run_rant"))
+
+# Everything written to $stdout during +yield+ will be returned. No
+# output to $stdout.
+def capture_stdout
+    tfn = "._ranttestcstdout.tmp"
+    if File.exist? tfn
+	raise <<-EOD
+When testing Rant: `#{Dir.pwd + "/" + tfn}' exists.
+  The testing process temporarily needs this file. Ensure that the
+  file doesn't contain data useful for you and try to remove it.
+  (Perhaps this file was left by an earlier testrun.)
+	EOD
+    end
+    begin
+	stdout = $stdout
+	File.open(tfn, "w") { |tf|
+	    $stdout = tf
+	    yield
+	}
+	o = File.read tfn
+    ensure
+	$stdout = stdout
+	File.delete tfn if File.exist? tfn
+    end
+end
+
+def capture_stderr
+    tfn = "._ranttestcstderr.tmp"
+    if File.exist? tfn
+	raise <<-EOD
+When testing Rant: `#{Dir.pwd + "/" + tfn}' exists.
+  The testing process temporarily needs this file. Ensure that the
+  file doesn't contain data useful for you and try to remove it.
+  (Perhaps this file was left by an earlier testrun.)
+	EOD
+    end
+    begin
+	stderr = $stderr
+	File.open(tfn, "w") { |tf|
+	    $stderr = tf
+	    yield
+	}
+	o = File.read tfn
+    ensure
+	$stderr = stderr
+	File.delete tfn if File.exist? tfn
+    end
+end
+
+def capture_std
+    outfn = "._ranttestcstdout.tmp"
+    errfn = "._ranttestcstderr.tmp"
+    if File.exist? outfn
+	raise <<-EOD
+When testing Rant: `#{Dir.pwd + "/" + outfn}' exists.
+  The testing process temporarily needs this file. Ensure that the
+  file doesn't contain data useful for you and try to remove it.
+  (Perhaps this file was left by an earlier testrun.)
+	EOD
+    end
+    if File.exist? errfn
+	raise <<-EOD
+When testing Rant: `#{Dir.pwd + "/" + errfn}' exists.
+  The testing process temporarily needs this file. Ensure that the
+  file doesn't contain data useful for you and try to remove it.
+  (Perhaps this file was left by an earlier testrun.)
+	EOD
+    end
+    begin
+	stdout = $stdout
+	stderr = $stderr
+	File.open(outfn, "w") { |of|
+	    $stdout = of
+	    File.open(errfn, "w") { |ef|
+		$stderr = ef
+		yield
+	    }
+	}
+	[File.read(outfn), File.read(errfn)]
+    ensure
+	$stderr = stderr
+	$stdout = stdout
+	File.delete outfn if File.exist? outfn
+	File.delete errfn if File.exist? errfn
+    end
+end
+
+def run_rant(*args)
+    `#{Rant::Env::RUBY} #{RANT_BIN} #{args.join(' ')}`
+end