GUnit 0.3.2 → 0.3.3

data/VERSION

@@ -1 +1 @@
-0.3.2
+0.3.3

data/gunit.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{GUnit}
-  s.version = "0.3.2"
+  s.version = "0.3.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Greg Sterndale"]
-  s.date = %q{2010-01-30}
+  s.date = %q{2010-02-03}
   s.description = %q{GUnit is a fresh new XUnit Test implementation, poppin' a cap in the ass of TestUnit. Just playin'. TestUnit is the shizzle.}
   s.email = %q{gsterndale@gmail.com}
   s.extra_rdoc_files = [

data/lib/gunit/assertions.rb

@@ -57,10 +57,9 @@ module GUnit
         false
       else
         case expected
-        when String   then actual.to_s == expected
         when Class    then actual.is_a?(expected)
         when nil      then !actual.nil?
-        else;              actual == expected
+        else;              actual.to_s == expected
         end
       end
 

data/lib/gunit/test_case.rb

@@ -38,8 +38,8 @@ module GUnit
       at_exit { subclass.autorun }
     end
 
-    def self.autorun=(a)
-      @@autorun = !a.nil? && a
+    def self.autorun=(bool)
+      @@autorun = !bool.nil? && bool
     end
 
     def self.autorun?
@@ -65,7 +65,7 @@ module GUnit
 
     def self.test_methods(prefix=TEST_METHOD_PREFIX)
       method_names = instance_methods.find_all{|method| method =~ /\A#{prefix}/ && ! GUnit::TestCase.instance_methods.include?(method) }
-      method_names.map!{|m| m.to_sym }
+      method_names.map!{|method_name| method_name.to_sym }
     end
     
     def self.context_for_method(method_name)
@@ -73,11 +73,7 @@ module GUnit
     end
     
     def self.context(*args, &blk)
-      new_context = if blk
-        GUnit::Context.new(args.first, &blk)
-      else
-        GUnit::Context.new(args.first)
-      end
+      new_context = GUnit::Context.new(args.first, &blk)
       new_context.parent = current_context
       @@context_stack << new_context
       current_context.run(self)
@@ -85,41 +81,26 @@ module GUnit
     end
     
     def self.setup(*args, &blk)
-      setup = if blk
-        GUnit::Setup.new(args.first, &blk)
-      else
-        GUnit::Setup.new(args.first)
-      end
+      setup = GUnit::Setup.new(args.first, &blk)
       current_context.setups << setup
     end
     
     def self.exercise(*args, &blk)
-      exercise = if blk
-        GUnit::Exercise.new(args.first, &blk)
-      else
-        GUnit::Exercise.new(args.first)
-      end
+      exercise = GUnit::Exercise.new(args.first, &blk)
       current_context.exercise = exercise
     end
     
     def self.teardown(*args, &blk)
-      teardown = if blk
-        GUnit::Teardown.new(args.first, &blk)
-      else
-        GUnit::Teardown.new(args.first)
-      end
+      teardown = GUnit::Teardown.new(args.first, &blk)
       current_context.teardowns << teardown
     end
     
     def self.verify(*args, &blk)
       test_method_name = message_to_unique_test_method_name(args.first)
       define_method(test_method_name) do
-        verification = if blk
-          GUnit::Verification.new(args.first, &blk)
-        else
-          GUnit::Verification.new(args.first)
-        end
+        verification = GUnit::Verification.new(args.first, &blk)
         verification.run(self)
+        GUnit::PassResponse.new(verification.message)
       end
       @@method_count += 1
       @@test_method_contexts[test_method_name] = current_context
@@ -143,13 +124,20 @@ module GUnit
       self.run_excercise
       response = self.send(self.method_name.to_sym)
       self.run_teardowns
-      response
+    rescue GUnit::NothingToDo => e
+      response = ToDoResponse.new(e.message, e.backtrace)
+    rescue GUnit::AssertionFailure => e
+      response = FailResponse.new(e.message, e.backtrace)
+    rescue ::Exception => e
+      response = ExceptionResponse.new(e.message, e.backtrace)
+    ensure
+      return response
     end
 
   protected
   	
     def run_setups
-      self.context.all_setups.each {|s| s.run(self) }
+      self.context.all_setups.each {|setup| setup.run(self) }
     end
     
     def run_excercise
@@ -157,7 +145,7 @@ module GUnit
     end
     
     def run_teardowns
-      self.context.all_teardowns.reverse.each {|t| t.run(self) } if self.context
+      self.context.all_teardowns.reverse.each {|teardown| teardown.run(self) } if self.context
     end
     
     def self.current_context

data/lib/gunit/test_response.rb

@@ -9,12 +9,12 @@ module GUnit
     
     # FailResponse.new("my message")
     def initialize(*args)
-      self.message = args.find{|a| a.is_a?(String) } || self.class::DEFAULT_MESSAGE
-      self.backtrace = args.find{|a| a.is_a?(Array) } || []
+      self.message = args.find{|arg| arg.is_a?(String) } || self.class::DEFAULT_MESSAGE
+      self.backtrace = args.find{|arg| arg.is_a?(Array) } || []
     end
     
-    def backtrace=(a=[])
-      @backtrace = a
+    def backtrace=(traces=[])
+      @backtrace = traces
       discover_file_name
       discover_line_number
       @backtrace

data/lib/gunit/test_runner.rb

@@ -80,19 +80,19 @@ module GUnit
     end
     
     def passes
-      @responses.find_all{|r| r.is_a? PassResponse }
+      @responses.find_all{|response| response.is_a? PassResponse }
     end
     
     def fails
-      @responses.find_all{|r| r.is_a? FailResponse }
+      @responses.find_all{|response| response.is_a? FailResponse }
     end
     
     def exceptions
-      @responses.find_all{|r| r.is_a? ExceptionResponse }
+      @responses.find_all{|response| response.is_a? ExceptionResponse }
     end
     
     def to_dos
-      @responses.find_all{|r| r.is_a? ToDoResponse }
+      @responses.find_all{|response| response.is_a? ToDoResponse }
     end
     
   protected
@@ -109,7 +109,7 @@ module GUnit
 
     def print_responses_summary
       @io.puts ""
-      @responses.select{|r| !r.is_a?(GUnit::PassResponse) }.each do |response|
+      @responses.select{|response| !response.is_a?(GUnit::PassResponse) }.each do |response|
         @io.print self.class.response_color(response)
         @io.print "#{response.message} (#{response.file_name}:#{response.line_number})\n"
         @io.print DEFAULT_COLOR
@@ -118,8 +118,8 @@ module GUnit
     end
 
     # Flatten array of TestSuites and TestCases into a single dimensional array of TestCases
-    def test_cases(a=self.tests)
-      a.map do |test|
+    def test_cases(test_suites_cases=self.tests)
+      test_suites_cases.map do |test|
         case test
         when GUnit::TestSuite
           test_cases(test.tests)

data/lib/gunit/verification.rb

@@ -1,5 +1,8 @@
 module GUnit
-  
+
+  class NothingToDo < StandardError
+  end
+
   class Verification
     attr_writer :message
     attr_accessor :task
@@ -13,19 +16,9 @@ module GUnit
     end
     
     def run(binding=self)
-      begin
-        if @task.is_a?(Proc)
-          bound_task = @task.bind(binding)
-          bound_task.call
-          PassResponse.new
-        else
-          ToDoResponse.new(self.message, Kernel.caller)
-        end
-      rescue GUnit::AssertionFailure => e
-        FailResponse.new(e.message, e.backtrace)
-      rescue ::Exception => e
-        ExceptionResponse.new(e.message, e.backtrace)
-      end
+      raise GUnit::NothingToDo.new(self.message) unless @task.is_a?(Proc) # Kernel.caller
+      bound_task = @task.bind(binding)
+      bound_task.call
     end
     
     def message

data/test/unit/assertions_test.rb

@@ -98,7 +98,7 @@ class FooTest < Test::Unit::TestCase
     end
   end
   
-  def test_assert_raises_two_args_one_block
+  def test_assert_raises_string_message_block
     block     = Proc.new { raise "boom" }
     expected  = "boom"
     message   = "my message here"
@@ -106,7 +106,7 @@ class FooTest < Test::Unit::TestCase
     assert result === true
   end
   
-  def test_assert_raises_two_args_with_class_one_block
+  def test_assert_raises_class_message_block
     block     = Proc.new { raise StandardError }
     expected  = StandardError
     message   = "my message here"
@@ -114,14 +114,14 @@ class FooTest < Test::Unit::TestCase
     assert result === true
   end
   
-  def test_assert_raises_one_arg_one_block
+  def test_assert_raises_string_block
     block     = Proc.new { raise "boom" }
     expected  = "boom"
     result    = @foo1.assert_raises expected, &block
     assert result === true
   end
   
-  def test_assert_raises_one_block
+  def test_assert_raises_block_only
     block   = Proc.new { raise "boom" }
     result  = @foo1.assert_raises &block
     assert result === true

data/test/unit/test_case_test.rb

@@ -82,11 +82,13 @@ class GUnit::TestCaseTest < Test::Unit::TestCase
     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)
+    message = 'The truth'
+    verification = mock(:message => message, :run => true)
     GUnit::Verification.expects(:new).with(args).returns(verification)
-    assert_equal todo, MyClassTest.new.send(dynamic_method_name)
+    response = MyClassTest.new.send(dynamic_method_name)
+    assert response.is_a?(GUnit::TestResponse)
+    assert response.is_a?(GUnit::PassResponse)
+    assert_equal message, response.message
   end
   
   def test_verify_with_block_creates_instance_method
@@ -97,12 +99,14 @@ class GUnit::TestCaseTest < Test::Unit::TestCase
     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)
+    message = 'The truth'
+    verification = mock(:message => message, :run => true)
 # 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)
+    GUnit::Verification.expects(:new).returns(verification)
+    response = MyClassTest.new.send(dynamic_method_name)
+    assert response.is_a?(GUnit::TestResponse)
+    assert response.is_a?(GUnit::PassResponse)
+    assert_equal message, response.message
   end
   
   def test_run_runs_setups
@@ -142,7 +146,52 @@ class GUnit::TestCaseTest < Test::Unit::TestCase
     @my_test_case3.run
     assert_equal "zip", @my_test_case3.instance_variable_get("@foo")
   end
-  
+
+  def test_run_with_test_method_raising_assertion_failure
+    exception_message = 'Whoops'
+    exception = GUnit::AssertionFailure.new(exception_message)
+    verify_message = "The truth"
+    verification = mock
+    verification.expects(:run).raises(exception)
+    dynamic_method_name = MyClassTest.verify(verify_message)
+    GUnit::Verification.expects(:new).with(verify_message).returns(verification)
+    @my_test_case4 = MyClassTest.new(dynamic_method_name)
+    response = @my_test_case4.run
+    assert response.is_a?(GUnit::TestResponse)
+    assert response.is_a?(GUnit::FailResponse)
+    assert_equal exception_message, response.message
+  end
+
+  def test_run_with_test_method_raising_nothing_to_do_exception
+    exception_message = 'Nothin here'
+    exception = GUnit::NothingToDo.new(exception_message)
+    verify_message = "The truth"
+    verification = mock
+    verification.expects(:run).raises(exception)
+    dynamic_method_name = MyClassTest.verify(verify_message)
+    GUnit::Verification.expects(:new).with(verify_message).returns(verification)
+    @my_test_case5 = MyClassTest.new(dynamic_method_name)
+    response = @my_test_case5.run
+    assert response.is_a?(GUnit::TestResponse)
+    assert response.is_a?(GUnit::ToDoResponse)
+    assert_equal exception_message, response.message
+  end
+
+  def test_run_with_test_method_raising_random_exception
+    exception_message = 'Whoops'
+    exception = ::StandardError.new(exception_message)
+    verify_message = "The truth"
+    verification = mock
+    verification.expects(:run).raises(exception)
+    dynamic_method_name = MyClassTest.verify(verify_message)
+    GUnit::Verification.expects(:new).with(verify_message).returns(verification)
+    @my_test_case5 = MyClassTest.new(dynamic_method_name)
+    response = @my_test_case5.run
+    assert response.is_a?(GUnit::TestResponse)
+    assert response.is_a?(GUnit::ExceptionResponse)
+    assert_equal exception_message, response.message
+  end
+
   def test_test_methods
     assert MyClassTest.test_methods.include?(:test_one)
     assert MyClassTest.test_methods.include?(:test_two)

data/test/unit/verification_test.rb

@@ -52,46 +52,34 @@ class GUnit::VerificationTest < Test::Unit::TestCase
   def test_run_with_task_called_returns_true
     @verification1.task = lambda { true }
     response = @verification1.run
-    assert response.is_a?(GUnit::TestResponse)
-    assert response.is_a?(GUnit::PassResponse)
+    assert response === true
   end
   
   def test_run_with_task_called_returns_false
     @verification1.task = lambda { false }
     response = @verification1.run
-    assert response.is_a?(GUnit::TestResponse)
-    assert response.is_a?(GUnit::PassResponse)
+    assert response === false
   end
   
   def test_run_with_task_is_false
     @verification1.task = false
-    response = @verification1.run
-    assert response.is_a?(GUnit::TestResponse)
-    assert response.is_a?(GUnit::ToDoResponse)
+    assert_raise GUnit::NothingToDo do
+      @verification1.run
+    end
   end
   
   def test_run_with_task_is_nil
     message = 'Not dun yet'
-    stack = ["./samples/../lib/gunit/verification.rb:25:in `test_not_dun_yet'",
-             "./samples/../lib/gunit/verification.rb:25:in `test_not_dun_yet'",
-             "./samples/../lib/gunit/test_case.rb:38:in `send'",
-             "./samples/../lib/gunit/test_case.rb:38:in `run'",
-             "./samples/../lib/gunit/test_suite.rb:21:in `run'",
-             "./samples/../lib/gunit/test_suite.rb:16:in `each'",
-             "./samples/../lib/gunit/test_suite.rb:16:in `run'",
-             "./samples/../lib/gunit/test_runner.rb:44:in `run'",
-             "./samples/../lib/gunit/test_runner.rb:41:in `each'",
-             "./samples/../lib/gunit/test_runner.rb:41:in `run'",
-             "samples/foo_sample.rb:177"]
-    to_do_response = GUnit::ToDoResponse.new(message, stack)
     @verification1.message = message
     @verification1.task = nil
-    GUnit::ToDoResponse.expects(:new).with{|m,b| m == message && b.is_a?(Array) }.once.returns(to_do_response)
-    response = @verification1.run
-    assert response.is_a?(GUnit::TestResponse)
-    assert response.is_a?(GUnit::ToDoResponse)
-    assert_equal message, response.message
-    assert_equal stack, response.backtrace
+    assert_raise GUnit::NothingToDo do
+      @verification1.run
+    end
+    begin
+      @verification1.run
+    rescue GUnit::NothingToDo => exception
+      assert_equal message, exception.message     
+    end
   end
   
   def test_run_with_binding
@@ -103,31 +91,5 @@ class GUnit::VerificationTest < Test::Unit::TestCase
     @verification1.run(obj)
     assert_equal "zip", obj.instance_variable_get("@foo")
   end
-  
-  def test_run_with_assertion_failure_exception
-    message = "boooooooom"
-    backtrace = ['ohnoes']
-    assertion_failure = GUnit::AssertionFailure.new(message)
-    assertion_failure.expects(:backtrace).at_least_once.returns(backtrace)
-    @verification1.task = lambda { raise assertion_failure }
-    response = @verification1.run
-    assert response.is_a?(GUnit::TestResponse)
-    assert response.is_a?(GUnit::FailResponse)
-    assert_equal message, response.message
-    assert_equal backtrace, response.backtrace
-  end
-  
-  def test_run_with_random_exception
-    message = "boooooooom"
-    backtrace = ['ohnoes']
-    exception = Exception.new(message)
-    exception.set_backtrace(backtrace)
-    @verification1.task = lambda { raise exception }
-    response = @verification1.run
-    assert response.is_a?(GUnit::TestResponse)
-    assert response.is_a?(GUnit::ExceptionResponse)
-    assert_equal message, response.message
-    assert_equal backtrace, response.backtrace
-  end
-    
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: GUnit
 version: !ruby/object:Gem::Version 
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors: 
 - Greg Sterndale
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-30 00:00:00 -05:00
+date: 2010-02-03 00:00:00 -05:00
 default_executable: 
 dependencies: []