GUnit 0.1.2

data/test/unit/context_test.rb

@@ -0,0 +1,129 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+# class MyClassTest < GUnit::TestCase
+#   setup "Some fixtures should be created here"
+#   
+#   context "An instance of MyClass"
+#     setup "my fixture with attributes" do
+#       ...
+#     end
+#   end
+# end
+
+class GUnit::ContextTest < Test::Unit::TestCase
+  
+  def setup
+    @context1 = GUnit::Context.new
+  end
+  
+  def test_it_is_a_setup
+    assert @context1.is_a?(GUnit::Context)
+  end
+  
+  def test_has_default_message
+    assert_not_nil @context1.message
+    assert @context1.message.is_a?(String)
+  end
+  
+  def test_message_setter
+    message = "Set something up"
+    @context1.message = message
+    assert_equal message, @context1.message
+  end
+  
+  def test_setups_setter
+    setups = [GUnit::Setup.new, GUnit::Setup.new]
+    @context1.setups = setups
+    assert_equal setups, @context1.setups
+  end
+  
+  def test_teardowns_setter
+    teardowns = [GUnit::Teardown.new, GUnit::Teardown.new]
+    @context1.teardowns = teardowns
+    assert_equal teardowns, @context1.teardowns
+  end
+  
+  def test_parent_setter
+    parent = GUnit::Context.new
+    @context1.parent = parent
+    assert_equal parent, @context1.parent
+  end
+  
+  def test_message_with_parent
+    parent = GUnit::Context.new
+    parent.message = "Mom"
+    message = "Kid"
+    @context1.parent = parent
+    @context1.message = message
+    assert_equal parent.message + ' ' + message, @context1.all_message
+  end
+  
+  def test_setups_with_parent
+    parent = GUnit::Context.new
+    parent.setups = [GUnit::Setup.new, GUnit::Setup.new]
+    setups = [GUnit::Setup.new, GUnit::Setup.new]
+    @context1.parent = parent
+    @context1.setups = setups
+    assert_equal parent.setups  + setups, @context1.all_setups
+  end
+  
+  def test_teardowns_with_parent
+    parent = GUnit::Context.new
+    parent.teardowns = [GUnit::Teardown.new, GUnit::Teardown.new]
+    teardowns = [GUnit::Teardown.new, GUnit::Teardown.new]
+    @context1.parent = parent
+    @context1.teardowns = teardowns
+    assert_equal parent.teardowns  + teardowns, @context1.all_teardowns
+  end
+  
+  # Context.new('my fixtures')
+  def test_initialize_with_one_arg
+    message = 'my fixtures'
+    @setup2 = GUnit::Context.new(message)
+    assert @setup2.message === message
+  end
+  
+  # Context.new('my fixtures'){ @foo = "bar" }
+  def test_initialize_with_one_arg_and_block
+    message = 'my fixtures'
+    task    = (@foo = "bar")
+    @setup2 = GUnit::Context.new(message) { (@foo = "bar") }
+    assert message === @setup2.message
+    assert task === @setup2.task.call
+  end
+  
+  def test_run_with_task_called_returns_true
+    @context1.task = Proc.new { true }
+    response = @context1.run
+    assert response === true
+  end
+  
+  def test_run_with_task_called_returns_false
+    @context1.task = Proc.new { false }
+    response = @context1.run
+    assert response === true
+  end
+  
+  def test_run_with_task_is_false
+    @context1.task = false
+    response = @context1.run
+    assert response === true
+  end
+  
+  def test_run_with_task_is_nil
+    @context1.task = nil
+    response = @context1.run
+    assert response === true
+  end
+  
+  def test_run_with_binding
+    obj = Object.new
+    obj.instance_variable_set("@foo", "bar")
+    @context1.task = Proc.new { instance_variable_set("@foo", "zip") }
+    @context1.run
+    assert_equal "bar", obj.instance_variable_get("@foo")
+    @context1.run(obj)
+    assert_equal "zip", obj.instance_variable_get("@foo")
+  end
+  
+end

data/test/unit/fail_response_test.rb

@@ -0,0 +1,31 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class GUnit::FailResponseTest < Test::Unit::TestCase
+  
+  def setup
+    @fail_response1 = GUnit::FailResponse.new
+  end
+  
+  def test_it_is_a_fail_response
+    assert @fail_response1.is_a?(GUnit::FailResponse)
+  end
+  
+  def test_has_default_message
+    assert_not_nil @fail_response1.message
+    assert @fail_response1.message != ''
+  end
+  
+  def test_message_setter
+    message = "Whoops."
+    @fail_response1.message = message
+    assert_equal message, @fail_response1.message
+  end
+  
+  # FailResponse.new('my fixtures')
+  def test_initialize_with_one_arg
+    message = 'Uhohs'
+    @fail_response2 = GUnit::FailResponse.new(message)
+    assert @fail_response2.message === message
+  end
+  
+end

data/test/unit/proc_extensions_test.rb

@@ -0,0 +1,24 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class GUnit::ProcExtensionsTest < Test::Unit::TestCase
+  
+  @@proc = Proc.new { bound_to }
+  
+  def self.bound_to
+    :class
+  end
+  
+  def bound_to
+    :instance
+  end
+  
+  def test_bind
+    p = @@proc
+    assert self.class.bound_to == :class
+    assert p.call == :class
+    p = p.bind(self)
+    assert self.bound_to == :instance
+    assert p.call == :instance
+  end
+  
+end

data/test/unit/setup_test.rb

@@ -0,0 +1,97 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+# class MyClassTest < GUnit::TestCase
+#   setup "Some fixtures should be created here"
+#   
+#   context "An instance of MyClass"
+#     setup "my fixture with attributes" do
+#       ...
+#     end
+#   end
+# end
+
+class GUnit::SetupTest < Test::Unit::TestCase
+  
+  def setup
+    @setup1 = GUnit::Setup.new
+  end
+  
+  def test_it_is_a_setup
+    assert @setup1.is_a?(GUnit::Setup)
+  end
+  
+  def test_has_default_message
+    assert_not_nil @setup1.message
+  end
+  
+  def test_message_setter
+    message = "Set something up"
+    @setup1.message = message
+    assert_equal message, @setup1.message
+  end
+  
+  # Setup.new('my fixtures')
+  def test_initialize_with_one_arg
+    message = 'my fixtures'
+    @setup2 = GUnit::Setup.new(message)
+    assert @setup2.message === message
+  end
+  
+  # Setup.new('my fixtures'){ @foo = "bar" }
+  def test_initialize_with_one_arg_and_block
+    message = 'my fixtures'
+    task    = (@foo = "bar")
+    @setup2 = GUnit::Setup.new(message) { (@foo = "bar") }
+    assert message === @setup2.message
+    assert task === @setup2.task.call
+  end
+  
+  def test_run_with_task_called_returns_true
+    @setup1.task = Proc.new { true }
+    response = @setup1.run
+    assert response === true
+  end
+  
+  def test_run_with_task_called_returns_false
+    @setup1.task = Proc.new { false }
+    response = @setup1.run
+    assert response === true
+  end
+  
+  def test_run_with_task_is_false
+    @setup1.task = false
+    response = @setup1.run
+    assert response === true
+  end
+  
+  def test_run_with_task_is_nil
+    @setup1.task = nil
+    response = @setup1.run
+    assert response === true
+  end
+  
+  def test_run_with_assertion_failure_exception
+    @setup1.task = lambda { raise GUnit::AssertionFailure }
+    response = @setup1.run
+    assert response.is_a?(GUnit::TestResponse)
+    assert response.is_a?(GUnit::FailResponse)
+  end
+  
+  def test_run_with_random_exception
+    @setup1.task = lambda { raise 'Boom' }
+    response = @setup1.run
+    assert response.is_a?(GUnit::TestResponse)
+    assert response.is_a?(GUnit::ExceptionResponse)
+  end
+  
+  def test_run_with_binding
+    obj = Object.new
+    obj.instance_variable_set("@foo", "bar")
+    @setup1.task = Proc.new { instance_variable_set("@foo", "zip") }
+    @setup1.run
+    assert_equal "bar", obj.instance_variable_get("@foo")
+    @setup1.run(obj)
+    assert_equal "zip", obj.instance_variable_get("@foo")
+  end
+  
+end

data/test/unit/teardown_test.rb

@@ -0,0 +1,97 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+# class MyClassTest < GUnit::TestCase
+#   teardown "Delete some fixtures here"
+#   
+#   context "An instance of MyClass"
+#     teardown "delete my fixture" do
+#       ...
+#     end
+#   end
+# end
+
+class GUnit::TeardownTest < Test::Unit::TestCase
+  
+  def setup
+    @teardown1 = GUnit::Teardown.new
+  end
+  
+  def test_it_is_a_teardown
+    assert @teardown1.is_a?(GUnit::Teardown)
+  end
+  
+  def test_has_default_message
+    assert_not_nil @teardown1.message
+  end
+  
+  def test_message_setter
+    message = "Set something up"
+    @teardown1.message = message
+    assert_equal message, @teardown1.message
+  end
+  
+  # Teardown.new('my fixtures')
+  def test_initialize_with_one_arg
+    message = 'my fixtures'
+    @teardown2 = GUnit::Teardown.new(message)
+    assert @teardown2.message === message
+  end
+  
+  # Teardown.new('my fixtures'){ @foo = "bar" }
+  def test_initialize_with_one_arg_and_block
+    message = 'my fixtures'
+    task    = (@foo = "bar")
+    @teardown2 = GUnit::Teardown.new(message) { (@foo = "bar") }
+    assert message === @teardown2.message
+    assert task === @teardown2.task.call
+  end
+  
+  def test_run_with_task_called_returns_true
+    @teardown1.task = Proc.new { true }
+    response = @teardown1.run
+    assert response === true
+  end
+  
+  def test_run_with_task_called_returns_false
+    @teardown1.task = Proc.new { false }
+    response = @teardown1.run
+    assert response === true
+  end
+  
+  def test_run_with_task_is_false
+    @teardown1.task = false
+    response = @teardown1.run
+    assert response === true
+  end
+  
+  def test_run_with_task_is_nil
+    @teardown1.task = nil
+    response = @teardown1.run
+    assert response === true
+  end
+  
+  def test_run_with_assertion_failure_exception
+    @teardown1.task = lambda { raise GUnit::AssertionFailure }
+    response = @teardown1.run
+    assert response.is_a?(GUnit::TestResponse)
+    assert response.is_a?(GUnit::FailResponse)
+  end
+  
+  def test_run_with_random_exception
+    @teardown1.task = lambda { raise 'Boom' }
+    response = @teardown1.run
+    assert response.is_a?(GUnit::TestResponse)
+    assert response.is_a?(GUnit::ExceptionResponse)
+  end
+  
+  def test_run_with_binding
+    obj = Object.new
+    obj.instance_variable_set("@foo", "bar")
+    @teardown1.task = Proc.new { instance_variable_set("@foo", "zip") }
+    @teardown1.run
+    assert_equal "bar", obj.instance_variable_get("@foo")
+    @teardown1.run(obj)
+    assert_equal "zip", obj.instance_variable_get("@foo")
+  end
+  
+end

data/test/unit/test_case_test.rb

@@ -0,0 +1,201 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class MyClass
+end
+
+class MyClassTest < GUnit::TestCase
+  def test_one
+  end
+  def test_two
+  end
+  def not_a_test_method
+  end
+end
+
+class GUnit::TestCaseTest < Test::Unit::TestCase
+  
+  def setup
+    @my_test_case = MyClassTest.new
+  end
+  
+  def test_it_is_a_test_case
+    assert @my_test_case.is_a?(GUnit::TestCase)
+  end
+  
+  def test_method_name_setter_getter
+    method_name = "my_method"
+    assert_not_equal method_name, @my_test_case.method_name
+    @my_test_case.method_name = method_name
+    assert_equal method_name, @my_test_case.method_name
+  end
+  
+  def test_constructor
+    method_name = "my_method"
+    @my_test_case1 = MyClassTest.new()
+    assert_not_equal method_name, @my_test_case1.method_name
+    @my_test_case1 = MyClassTest.new(method_name)
+    assert_equal method_name, @my_test_case1.method_name
+  end
+  
+  def test_run_calls_method_name
+    method_name = "my_method"
+    @my_test_case1 = MyClassTest.new(method_name)
+    @my_test_case1.expects(method_name.to_sym)
+    @my_test_case1.run
+  end
+  
+  def test_run_returns_method_result
+    method_name = "my_method"
+    result      = "my result"
+    @my_test_case1 = MyClassTest.new(method_name)
+    @my_test_case1.expects(method_name.to_sym).returns(result)
+    assert_equal result, @my_test_case1.run
+  end
+  
+  def test_message_to_test_method_name
+    msg = "Check for expected outcome"
+    method_name = MyClassTest.message_to_test_method_name(msg)
+    assert method_name.is_a?(Symbol)
+    assert method_name.to_s =~ /#{MyClassTest::TEST_METHOD_PREFIX}_check_for_expected_outcome/
+  end
+  
+  def test_verify_creates_instance_method
+    method_count = MyClassTest.instance_methods.length
+    args = "TODO add some feature"
+    dynamic_method_name = MyClassTest.verify(args)
+    assert_equal method_count + 1, MyClassTest.instance_methods.length
+    assert dynamic_method_name.to_s =~ /#{MyClassTest::TEST_METHOD_PREFIX}/
+    assert MyClassTest.instance_methods.include?(dynamic_method_name.to_s)
+    verification = GUnit::Verification.new
+    todo = GUnit::ToDoResponse.new
+    verification.expects(:run).returns(todo)
+    GUnit::Verification.expects(:new).with(args).returns(verification)
+    assert_equal todo, MyClassTest.new.send(dynamic_method_name)
+  end
+  
+  def test_verify_with_block_creates_instance_method
+    method_count = MyClassTest.instance_methods.length
+    args = "The truth"
+    blk  = Proc.new{ true }
+    dynamic_method_name = MyClassTest.verify(args)
+    assert_equal method_count + 1, MyClassTest.instance_methods.length
+    assert dynamic_method_name.to_s =~ /#{MyClassTest::TEST_METHOD_PREFIX}/
+    assert MyClassTest.new.respond_to?(dynamic_method_name)
+    verification = GUnit::Verification.new
+    pass = GUnit::PassResponse.new
+    verification.expects(:run).returns(pass)
+# TODO how to set expectation that blk is passed to new() ???
+    GUnit::Verification.expects(:new).with(args).returns(verification)
+    assert_equal pass, MyClassTest.new.send(dynamic_method_name)
+  end
+  
+  def test_run_runs_setups
+    MyClassTest.setup { @foo = "bar" }
+    method_name = "test_one"
+    @my_test_case1 = MyClassTest.new(method_name)
+    @my_test_case1.run
+    assert_equal "bar", @my_test_case1.instance_variable_get("@foo")
+  end
+  
+  def test_run_runs_teardowns
+    @my_test_case2 = MyClassTest.new
+    MyClassTest.setup { @foo = "bar" }
+    MyClassTest.teardown { @foo = "zip" }
+    method_name = "test_one"
+    @my_test_case2 = MyClassTest.new(method_name)
+    @my_test_case2.run
+    assert_equal "zip", @my_test_case2.instance_variable_get("@foo")
+  end
+  
+  def test_run_runs_teardowns_in_reverse_order
+    @my_test_case3 = MyClassTest.new
+    MyClassTest.setup { @foo = "bar" }
+    MyClassTest.teardown { @foo = "zip" }
+    MyClassTest.teardown { @foo = "zap" }
+    method_name = "test_one"
+    @my_test_case3 = MyClassTest.new(method_name)
+    @my_test_case3.run
+    assert_equal "zip", @my_test_case3.instance_variable_get("@foo")
+  end
+  
+  def test_test_methods
+    assert MyClassTest.test_methods.include?(:test_one)
+    assert MyClassTest.test_methods.include?(:test_two)
+    assert ! MyClassTest.test_methods.include?(:not_a_test_method)
+  end
+  
+  def test_suite_returns_test_suite_with_test_cases
+    test_suite = MyClassTest.suite
+    assert test_suite.is_a?(GUnit::TestSuite)
+    assert test_suite.tests.find{|t| t.method_name == :test_one }
+    assert test_suite.tests.find{|t| t.method_name == :test_two }
+    assert_nil test_suite.tests.find{|t| t.method_name == :not_a_test_method}
+  end
+  
+  def test_assert_true
+    response = @my_test_case.assert(1==1)
+    assert response === true
+  end
+  
+  def test_assert_false
+    assert_raise GUnit::AssertionFailure do
+      @my_test_case.assert(1==0)
+    end
+  end
+  
+  def test_assert_with_exception_raised
+    boom = lambda{ raise RuntimeError }
+    assert_raise RuntimeError do
+      @my_test_case.assert( boom )
+    end
+  end
+  
+  def test_verify_inside_context_defines_test_method_with_context
+    context_msg   = "In some context"
+    verify_msg    = "This should be the case A"
+    MyClassTest.context(context_msg) do
+      verify(verify_msg) { true }
+    end
+    method_name = MyClassTest.message_to_test_method_name(verify_msg)
+    assert MyClassTest.method_defined?(method_name)
+    context = MyClassTest.context_for_method(method_name)
+    assert_not_nil context
+    assert_equal context_msg, context.message
+  end
+  
+  def test_setup_and_teardown_inside_context_creates_context_with_setup_and_teardown
+    context_msg   = "In some context"
+    setup_msg     = "Given this"
+    teardown_msg  = "Housekeeping"
+    verify_msg    = "This should be the case B"
+    MyClassTest.context(context_msg) do
+      setup(setup_msg) { @foo = "abc" }
+      teardown(teardown_msg) { @foo = "def" }
+      verify(verify_msg) { true }
+    end
+    method_name = MyClassTest.message_to_test_method_name(verify_msg)
+    context = MyClassTest.context_for_method(method_name)
+    assert_equal setup_msg, context.setups.last.message
+    assert_equal teardown_msg, context.teardowns.last.message
+  end
+  
+  def test_context_creates_context_with_parent
+    context_msg   = "In some context"
+    verify_msg    = "This should be the case C"
+    MyClassTest.context(context_msg) do
+      verify(verify_msg) { true }
+    end
+    method_name = MyClassTest.message_to_test_method_name(verify_msg)
+    context = MyClassTest.context_for_method(method_name)
+    assert_not_nil context.parent
+    assert context.parent.is_a?(GUnit::Context)
+  end
+  
+  def test_test_method_outside_context_block_has_context
+    method_name = 'test_one'
+    context = MyClassTest.context_for_method(method_name)
+    assert_not_nil context
+    assert context.is_a?(GUnit::Context)
+  end
+  
+end

data/test/unit/test_runner_test.rb

@@ -0,0 +1,118 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class GUnit::TestRunnerTest < Test::Unit::TestCase
+  
+  def setup
+    @test_runner = GUnit::TestRunner.new
+    io = Object.new
+    @test_runner.io = io
+    @test_runner.io.stubs(:print)
+    @test_runner.io.stubs(:puts)
+  end
+  
+  def test_it_is_a_test_runner
+    assert @test_runner.is_a?(GUnit::TestRunner)
+  end
+  
+  def test_tests_getter_setter
+    tests = [GUnit::TestSuite.new, GUnit::TestCase.new]
+    assert @test_runner.tests != tests
+    @test_runner.tests = tests
+    assert @test_runner.tests == tests
+  end
+  
+  def test_tests_set_nil_has_empty_tests
+    @test_runner.tests = nil
+    assert @test_runner.tests.empty?
+    assert @test_runner.tests.is_a?(Enumerable)
+  end
+  
+  def test_has_empty_responses
+    assert @test_runner.responses.empty?
+    assert @test_runner.responses.is_a?(Enumerable)
+  end
+  
+  def test_silent_default
+    assert ! @test_runner.silent
+  end
+  
+  def test_silent_getter_setter
+    silent = true
+    assert @test_runner.silent != silent
+    @test_runner.silent = silent
+    assert @test_runner.silent === silent
+  end
+  
+  def test_io_default
+    assert GUnit::TestRunner.new.io == STDOUT
+  end
+  
+  def test_silent_getter_setter
+    io = mock
+    assert @test_runner.io != io
+    @test_runner.io = io
+    assert @test_runner.io === io
+  end
+  
+  def test_run_silent
+    @test_runner.io = mock() # fails if any methods on io are called
+    @test_runner.silent = true
+    test_response1 = GUnit::PassResponse.new    
+    test_suite = GUnit::TestSuite.new
+    test_suite.expects(:run).yields(test_response1)
+    @test_runner.tests = [test_suite]
+    @test_runner.run
+  end
+  
+  def test_run_not_silent
+    fail_response_message = "Whoops. Failed."
+    
+    test_response1 = GUnit::PassResponse.new
+    test_response2 = GUnit::FailResponse.new(fail_response_message)
+    test_response3 = GUnit::ExceptionResponse.new
+    test_response4 = GUnit::ToDoResponse.new
+    
+    @test_runner.silent = false
+    io = mock
+    io.expects(:print).with(GUnit::TestRunner::PASS_CHAR).at_least(1)
+    io.expects(:print).with(GUnit::TestRunner::FAIL_CHAR).at_least(1)
+    io.expects(:print).with(GUnit::TestRunner::EXCEPTION_CHAR).at_least(1)
+    io.expects(:print).with(GUnit::TestRunner::TODO_CHAR).at_least(1)
+    io.stubs(:puts)
+    io.expects(:puts).with(fail_response_message).at_least(1)
+    @test_runner.io = io
+    
+    test_suite = GUnit::TestSuite.new
+    test_suite.expects(:run).multiple_yields(test_response1, test_response2, test_response4)
+    test_case = GUnit::TestCase.new
+    test_case.expects(:run).returns(test_response3)
+    @test_runner.tests = [test_suite, test_case]
+
+    @test_runner.run
+  end
+  
+  def test_run_runs_all_tests_saves_responses
+    test_response1 = GUnit::PassResponse.new
+    test_response2 = GUnit::FailResponse.new
+    test_response3 = GUnit::ExceptionResponse.new
+    test_response4 = GUnit::ToDoResponse.new
+    test_suite = GUnit::TestSuite.new
+    test_suite.expects(:run).multiple_yields(test_response1, test_response2, test_response4)
+    test_case = GUnit::TestCase.new
+    test_case.expects(:run).returns(test_response3)
+    @test_runner.tests = [test_suite, test_case]
+    
+    @test_runner.run
+    
+    assert @test_runner.responses.include?(test_response1)
+    assert @test_runner.passes.include?(test_response1)
+    assert @test_runner.responses.include?(test_response2)
+    assert @test_runner.fails.include?(test_response2)
+    assert @test_runner.responses.include?(test_response3)
+    assert @test_runner.exceptions.include?(test_response3)
+    assert @test_runner.responses.include?(test_response4)
+    assert @test_runner.to_dos.include?(test_response4)
+    assert @test_runner.responses.length == 4
+  end
+  
+end