GUnit 0.1.2

data/lib/gunit/test_runner.rb

@@ -0,0 +1,98 @@
+module GUnit
+  
+  # How many tests have run
+  # How many passing test responses
+  # How many failing test responses
+  # How many exception test responses
+  
+  # A TestRunner object discovers TestCase classes
+  # The TestRunner object calls suite() on all TestCase classes
+  # Each TestCase class returns a TestSuite object with instances of itself (TestCases) each with a method to be executed
+  # The TestRunner object calls run() on all TestSuite objects, collecting TestResponses
+  # Each TestSuite object calls run() on all of its TestCase objects, yielding TestResponses
+  # Each TestCase object executes its method, returning a TestResponse
+  # The TestRunner displays the TestResponses as they are yielded
+  # After all tests have run, the TestRunner displays a summery of results
+  
+  class TestRunner
+    
+    PASS_CHAR      = '.'
+    FAIL_CHAR      = 'F'
+    TODO_CHAR      = '*'
+    EXCEPTION_CHAR = 'E'
+    
+    # TestSuites and/or TestCases
+    attr_accessor :io, :silent
+    attr_writer :tests
+    attr_reader :responses
+    
+    def initialize(*args)
+      @responses = []
+      @io = STDOUT
+      STDOUT.sync = true
+      @silent = false
+    end
+    
+    def tests
+      @tests ||= []
+    end
+    
+    def run
+      self.tests.each do |test|
+        case
+        when test.is_a?(TestSuite)
+          test.run do |response|
+            @responses << response
+            @io.print self.class.response_character(response) unless self.silent
+          end
+        when test.is_a?(TestCase)
+          response = test.run
+          @responses << response
+          @io.print self.class.response_character(response) unless self.silent
+        end
+      end
+      
+      unless self.silent
+        @io.puts ""
+        fails.each do |fail|
+          @io.puts ""
+          @io.puts fail.message
+        end
+        @io.puts "#{@responses.length} verifications: #{passes.length} passed, #{fails.length} failed, #{exceptions.length} exceptions, #{to_dos.length} to-dos"
+      end
+    end
+    
+    def passes
+      @responses.find_all{|r| r.is_a? PassResponse }
+    end
+    
+    def fails
+      @responses.find_all{|r| r.is_a? FailResponse }
+    end
+    
+    def exceptions
+      @responses.find_all{|r| r.is_a? ExceptionResponse }
+    end
+    
+    def to_dos
+      @responses.find_all{|r| r.is_a? ToDoResponse }
+    end
+    
+  protected
+    
+    def self.response_character(response)
+      case
+      when response.is_a?(PassResponse)
+        PASS_CHAR
+      when response.is_a?(FailResponse)
+        FAIL_CHAR
+      when response.is_a?(ExceptionResponse)
+        EXCEPTION_CHAR
+      when response.is_a?(ToDoResponse)
+        TODO_CHAR
+      end
+    end
+    
+  end
+  
+end

data/lib/gunit/test_suite.rb

@@ -0,0 +1,29 @@
+module GUnit
+  
+  class TestSuite
+    
+    # TestCases (TODO and/or TestSuites)
+    attr_writer :tests
+    
+    def initialize()
+    end
+    
+    def tests
+      @tests ||= []
+    end
+    
+    def run(&blk)
+      self.tests.each do |test|
+        case
+        when test.is_a?(TestSuite)
+          test.run{|response| blk.call(response) if blk }
+        when test.is_a?(TestCase)
+          response = test.run
+          blk.call(response) if blk
+        end
+      end
+    end
+    
+  end
+  
+end

data/lib/gunit/to_do_response.rb

@@ -0,0 +1,6 @@
+module GUnit
+  
+  class ToDoResponse < TestResponse
+  end
+  
+end

data/lib/gunit/verification.rb

@@ -0,0 +1,43 @@
+module GUnit
+  
+  class Verification
+    attr_writer :message
+    attr_accessor :task
+    
+    # Verification.new("my message")
+    # Verification.new("my message") { assert true }
+    # Verification.new() { assert true }
+    def initialize(*args, &blk)
+      self.message = args[0]
+      self.task = blk if blk
+    end
+    
+    def run(binding=self)
+      begin
+        if @task.is_a?(Proc)
+          bound_task = @task.bind(binding)
+          bound_task.call
+          PassResponse.new
+        else
+          ToDoResponse.new
+        end
+      rescue GUnit::AssertionFailure => e
+        FailResponse.new(e.message)
+      rescue ::StandardError => e
+        ExceptionResponse.new
+      end
+    end
+    
+    def message
+      @message || default_message
+    end
+    
+    def default_message
+      "Verification failed!"
+    end
+    
+  end
+  
+end
+
+

data/lib/gunit.rb

@@ -0,0 +1,26 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'gunit/proc_extensions'
+
+require 'gunit/assertions'
+
+require 'gunit/context'
+
+require 'gunit/exercise'
+require 'gunit/setup'
+require 'gunit/teardown'
+require 'gunit/verification'
+
+require 'gunit/test_response'
+require 'gunit/exception_response'
+require 'gunit/fail_response'
+require 'gunit/pass_response'
+require 'gunit/to_do_response'
+
+require 'gunit/test_case'
+require 'gunit/test_suite'
+require 'gunit/test_runner'
+
+
+
+

data/test/integration/foo_test.rb

@@ -0,0 +1,182 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class Foo
+end
+
+class FooGUnitTest < GUnit::TestCase
+  
+  setup do
+    @foo = 'bar'
+  end
+  
+  verify "variable from setup" do
+    assert @foo == 'bar'
+    assert "foo is string" do
+      @foo.is_a?(String)
+    end
+    assert @foo.is_a?(String), "foo is string"
+    assert_equal 'bar', @foo, "foo is bar"
+  end
+  
+  verify do
+    assert 1 == 1
+  end
+  
+  verify "truth" do
+    assert true
+    
+    assert "one is one" do
+      1 == 1
+    end
+    
+    assert_equal 1, 1
+    assert_equal 1, 1, "one is one"
+    assert_equal 1 do
+      0 + 1
+    end
+    assert_equal 2, "one and one make two" do
+      1 + 1
+    end
+    assert_equal 2 do
+      1 + 1
+    end
+  end
+  
+  verify "failure here" do
+    assert false
+  end
+
+  verify "another failure here" do
+    assert @foo == 'wrong'
+  end
+  
+  verify "exceptional" do
+    assert_raises do
+      raise "BOOM!"
+    end
+  end
+  
+  verify "not exceptional" do
+    assert_raises do
+      true
+    end
+  end
+  
+  verify "unexpected" do
+    raise "BAM!!!"
+  end
+  
+  verify "not dun yet"
+  
+  context "An instance of Foo" do
+    # One setup per context
+    setup do
+      @foo = 'abc'
+    end
+    
+    # # One exercise per context
+    # exercise do
+    #   @foo.do_something
+    # end
+  
+    # One teardown per context
+    teardown do
+      @foo = nil
+    end
+    
+    # Many verifies per context
+    verify "abc's of foo" do
+      assert @foo == 'abc'
+    end
+    
+    # many nested contexts per context
+    context "doing something else" do
+      setup do
+        @foo = 'xyz'
+      end
+      teardown do
+        @foo = nil
+      end
+      verify "xyz's of foo" do
+        assert @foo == 'xyz'
+      end
+      verify "xyz's of foo" do
+        assert @foo == 'wrong'
+      end
+    end
+    
+    verify "abc's of foo" do
+      assert @foo == 'def'
+    end
+  end
+  
+  # # Custom macros
+  # verify_validity @foo
+  # verify_dirty @foo
+  # 
+  # # Many verifies per context, some share fixtures
+  # # setup, exercise and teardown will only be run once for all methods in this context with the second param == true
+  # verify "one and one is two", true do
+  #   assert 1+1 == 2
+  # end
+  # 
+  # # Many verifies per context, some share fixtures
+  # # setup, exercise and teardown will only be run once for all methods in this context with the second param == true
+  # verify "one is more than none", true do
+  #   assert 1 > 0
+  # end
+  #   
+  # # Many verifies per context
+  # verify "the truth" do
+  #   assert { true }
+  #   assert "true is true" { true }
+  #   assert true
+  #   assert_equal true, true
+  #   assert_equal true, true, "true is true"
+  #   assert_equal true, true, "true is true" {|a,b| a === b }
+  #   
+  #   assert_is_a @foo, Foo
+  # 
+  #   assert_nil nil
+  # 
+  #   assert_nil nil, "nil is nil"
+  # 
+  #   assert_raise do
+  #     raise RuntimeError
+  #   end
+  # 
+  #   assert_raise RuntimeError do
+  #     raise RuntimeError
+  #   end
+  # 
+  #   assert_raise RuntimeError, "blow up" do
+  #     raise RuntimeError
+  #   end
+  # end
+  # 
+  # verify "something changed" do
+  #   assert_change @foo.something, :by => -1
+  #   assert_change "@foo.something_else", :from => true, :to => false
+  #   assert_change "@foo.third_thing" {|before, after| before < after }
+  # end
+  
+end
+
+class FooGUnitTestTest < Test::Unit::TestCase
+  def setup
+    @test_runner = GUnit::TestRunner.new
+    @test_runner.io = mock('io')
+    @test_runner.io.stubs(:print)
+    @test_runner.io.stubs(:puts)
+    @test_runner.tests << FooGUnitTest.suite
+  end
+  
+  def test_run_test_runner
+    @test_runner.run
+    assert_equal 6, @test_runner.passes.length
+    assert_equal 5, @test_runner.fails.length
+    assert_equal 1, @test_runner.exceptions.length
+    assert_equal 1, @test_runner.to_dos.length
+  end
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+require 'erb'
+
+require 'ruby-debug'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'gunit'
+
+class Test::Unit::TestCase
+end

data/test/unit/assertions_test.rb

@@ -0,0 +1,190 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class Foo
+  include GUnit::Assertions
+end
+
+
+class FooTest < Test::Unit::TestCase
+  def setup
+    @foo1 = Foo.new
+  end
+  
+  def test_assert_no_arg_one_block
+    block   = Proc.new { 1==1 }
+    result  = @foo1.assert &block
+    assert result === true
+  end
+  
+  def test_assert_one_arg_one_block
+    message = "my message here"
+    block   = Proc.new { 1==1 }
+    result  = @foo1.assert message, &block
+    assert result === true
+  end
+  
+  def test_assert_two_args
+    message = "my message here"
+    bool    = 1==1
+    result  = @foo1.assert bool, message
+    assert result === true
+  end
+  
+  def test_assert_fails
+    message = "my message here"
+    block   = Proc.new { 1==0 }
+    assert_raise GUnit::AssertionFailure do
+      @foo1.assert message, &block
+    end
+    begin
+      @foo1.assert message, &block
+    rescue GUnit::AssertionFailure => e
+      assert_equal message, e.message
+    end
+  end
+  
+  def test_assert_fails_no_message
+    block   = Proc.new { 1==0 }
+    begin
+      @foo1.assert &block
+    rescue GUnit::AssertionFailure => e
+      assert e.message =~ /false != true/
+    end
+  end
+  
+  def test_assert_equal_two_args
+    expected = 1
+    actual   = 1
+    result   = @foo1.assert_equal expected, actual
+    assert result === true
+  end
+  
+  def test_assert_equal_one_arg_one_block
+    expected = 1
+    block    = Proc.new { 0 + 1 }
+    result   = @foo1.assert_equal expected, &block
+    assert result === true
+  end
+  
+  def test_assert_equal_two_args_one_block
+    expected = 1
+    block    = Proc.new { 0 + 1 }
+    message  = "my message here"
+    result   = @foo1.assert_equal expected, message, &block
+    assert result === true
+  end
+  
+  def test_assert_equal_fails
+    expected  = 2
+    message   = "my message here"
+    block     = Proc.new { 0 + 1 }
+    assert_raise GUnit::AssertionFailure do
+      @foo1.assert_equal expected, message, &block
+    end
+    begin
+      @foo1.assert_equal expected, message, &block
+    rescue GUnit::AssertionFailure => e
+      assert_equal message, e.message
+    end
+  end
+  
+  def test_assert_equal_fails_no_message
+    expected  = 2
+    block     = Proc.new { 0 + 1 }
+    begin
+      @foo1.assert_equal expected, &block
+    rescue GUnit::AssertionFailure => e
+      assert e.message =~ /1 != 2/
+    end
+  end
+  
+  def test_assert_raises_two_args_one_block
+    block     = Proc.new { raise "boom" }
+    expected  = "boom"
+    message   = "my message here"
+    result    = @foo1.assert_raises expected, message, &block
+    assert result === true
+  end
+  
+  def test_assert_raises_two_args_with_class_one_block
+    block     = Proc.new { raise StandardError }
+    expected  = StandardError
+    message   = "my message here"
+    result    = @foo1.assert_raises expected, message, &block
+    assert result === true
+  end
+  
+  def test_assert_raises_one_arg_one_block
+    block     = Proc.new { raise "boom" }
+    expected  = "boom"
+    result    = @foo1.assert_raises expected, &block
+    assert result === true
+  end
+  
+  def test_assert_raises_one_block
+    block   = Proc.new { raise "boom" }
+    result  = @foo1.assert_raises &block
+    assert result === true
+  end
+  
+  def test_assert_raises_fails
+    block     = Proc.new { raise "POWWWW" }
+    expected  = "boom"
+    message   = "my message here"
+    assert_raise GUnit::AssertionFailure do
+      @foo1.assert_raises expected, message, &block
+    end
+    begin
+      @foo1.assert_raises expected, message, &block
+    rescue GUnit::AssertionFailure => e
+      assert_equal message, e.message
+    end
+  end
+  
+  def test_assert_raises_with_class_fails
+    block     = Proc.new { raise Exception }
+    expected  = StandardError
+    message   = "my message here"
+    assert_raise GUnit::AssertionFailure do
+      @foo1.assert_raises expected, message, &block
+    end
+    begin
+      @foo1.assert_raises expected, message, &block
+    rescue GUnit::AssertionFailure => e
+      assert_equal message, e.message
+    end
+  end
+  
+  def test_assert_raises_fails_no_message
+    block     = Proc.new { raise Exception }
+    expected  = StandardError
+    begin
+      @foo1.assert_raises expected, &block
+    rescue GUnit::AssertionFailure => e
+      assert e.message =~ /Expected StandardError to be raised, but got Exception/
+    end
+  end
+  
+  def test_assert_raises_fails_nothing_raised_no_message
+    block     = Proc.new { true }
+    expected  = StandardError
+    begin
+      @foo1.assert_raises expected, &block
+    rescue GUnit::AssertionFailure => e
+      assert e.message =~ /Expected StandardError to be raised, but nothing raised/
+    end
+  end
+  
+  def test_assert_raises_fails_no_expected_nothing_raised
+    block     = Proc.new { true }
+    assert_raise GUnit::AssertionFailure do
+      @foo1.assert_raises &block
+    end
+    begin
+      @foo1.assert_raises &block
+    rescue GUnit::AssertionFailure => e
+      assert e.message =~ /Nothing raised/
+    end
+  end
+  
+end