GUnit 0.1.2 → 0.2.0

data/VERSION

@@ -1 +1 @@
-0.1.2
+0.2.0

data/gunit.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{GUnit}
-  s.version = "0.1.2"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Greg Sterndale"]
@@ -44,6 +44,7 @@ Gem::Specification.new do |s|
      "test/test_helper.rb",
      "test/unit/assertions_test.rb",
      "test/unit/context_test.rb",
+     "test/unit/exercise_test.rb",
      "test/unit/fail_response_test.rb",
      "test/unit/proc_extensions_test.rb",
      "test/unit/setup_test.rb",
@@ -63,6 +64,7 @@ Gem::Specification.new do |s|
      "test/test_helper.rb",
      "test/unit/assertions_test.rb",
      "test/unit/context_test.rb",
+     "test/unit/exercise_test.rb",
      "test/unit/fail_response_test.rb",
      "test/unit/proc_extensions_test.rb",
      "test/unit/setup_test.rb",

data/lib/gunit/context.rb

@@ -1,7 +1,7 @@
 module GUnit
   # Context instance has message, setups, exercises, teardowns, and parent (another Context)
   class Context
-    attr_accessor :task, :parent, :message, :setups, :teardowns
+    attr_accessor :task, :parent, :message, :setups, :exercise, :teardowns
     
     # Context.new("my message")
     # Context.new("my message") do
@@ -28,17 +28,17 @@ module GUnit
     end
     
     def all_message
-      parent_message = self.parent.message if self.parent
+      parent_message = self.parent.all_message if self.parent
       parent_message = nil if parent_message == ''
       [parent_message, @message].compact.join(' ')
     end
     
     def all_setups
-      (self.parent ? self.parent.setups : []) + @setups
+      (self.parent ? self.parent.all_setups : []) + @setups
     end
     
     def all_teardowns
-      (self.parent ? self.parent.teardowns : []) + @teardowns
+      (self.parent ? self.parent.all_teardowns : []) + @teardowns
     end
     
   end

data/lib/gunit/exercise.rb

@@ -0,0 +1,41 @@
+module GUnit
+  
+  class Exercise
+    attr_writer :message
+    attr_accessor :task
+    
+    # Exercise.new("my message")
+    # Exercise.new("my message") { @foo.bar() }
+    # Exercise.new() { @foo.bar() }
+    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
+        end
+        return true
+      rescue GUnit::AssertionFailure => e
+        FailResponse.new
+      rescue ::StandardError => e
+        ExceptionResponse.new
+      end
+    end
+    
+    def message
+      @message || default_message
+    end
+    
+    def default_message
+      "Exercise"
+    end
+    
+  end
+  
+end
+
+

data/lib/gunit/test_case.rb

@@ -17,7 +17,8 @@ module GUnit
     
     TEST_METHOD_PREFIX = 'test'
     
-    attr_accessor :method_name, :context
+    attr_accessor :method_name
+    attr_writer :context
     
     @@method_count          = 0
     @@context_stack         = [ GUnit::Context.new ]
@@ -33,6 +34,7 @@ module GUnit
     
     def run
       self.run_setups
+      self.run_excercise
       response = self.send(self.method_name.to_sym)
       self.run_teardowns
       response
@@ -77,6 +79,15 @@ module GUnit
       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
+      current_context.exercise = exercise
+    end
+    
     def self.teardown(*args, &blk)
       teardown = if blk
         GUnit::Teardown.new(args.first, &blk)
@@ -112,11 +123,15 @@ module GUnit
   protected
     
     def run_setups
-      self.context.setups.each {|s| s.run(self) }
+      self.context.all_setups.each {|s| s.run(self) }
     end
-  
+    
+    def run_excercise
+      self.context.exercise.run(self) if self.context && self.context.exercise
+    end
+    
     def run_teardowns
-      self.context.teardowns.reverse.each {|t| t.run(self) } if self.context
+      self.context.all_teardowns.reverse.each {|t| t.run(self) } if self.context
     end
     
     def self.current_context

data/test/integration/foo_test.rb

@@ -71,13 +71,13 @@ class FooGUnitTest < GUnit::TestCase
   context "An instance of Foo" do
     # One setup per context
     setup do
-      @foo = 'abc'
+      @foo = ''
     end
     
-    # # One exercise per context
-    # exercise do
-    #   @foo.do_something
-    # end
+    # One exercise per context
+    exercise do
+      @foo.replace 'abc'
+    end
   
     # One teardown per context
     teardown do
@@ -89,6 +89,13 @@ class FooGUnitTest < GUnit::TestCase
       assert @foo == 'abc'
     end
     
+    # Exercise outside of this context should not apply
+    context "doing something else" do
+      verify "emptiness of foo" do
+        assert @foo == '', "#{@foo.class} is not empty"
+      end
+    end
+    
     # many nested contexts per context
     context "doing something else" do
       setup do
@@ -173,7 +180,7 @@ class FooGUnitTestTest < Test::Unit::TestCase
   
   def test_run_test_runner
     @test_runner.run
-    assert_equal 6, @test_runner.passes.length
+    assert_equal 7, @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

data/test/unit/context_test.rb

@@ -16,7 +16,7 @@ class GUnit::ContextTest < Test::Unit::TestCase
     @context1 = GUnit::Context.new
   end
   
-  def test_it_is_a_setup
+  def test_it_is_a_context
     assert @context1.is_a?(GUnit::Context)
   end
   
@@ -31,6 +31,12 @@ class GUnit::ContextTest < Test::Unit::TestCase
     assert_equal message, @context1.message
   end
   
+  def test_exercise_setter
+    exercise = GUnit::Exercise.new
+    @context1.exercise = exercise
+    assert_equal exercise, @context1.exercise
+  end
+  
   def test_setups_setter
     setups = [GUnit::Setup.new, GUnit::Setup.new]
     @context1.setups = setups
@@ -49,31 +55,40 @@ class GUnit::ContextTest < Test::Unit::TestCase
     assert_equal parent, @context1.parent
   end
   
-  def test_message_with_parent
+  def test_message_with_parents
+    nana = GUnit::Context.new
+    nana.message = "Nana"
     parent = GUnit::Context.new
     parent.message = "Mom"
+    parent.parent = nana
     message = "Kid"
     @context1.parent = parent
     @context1.message = message
-    assert_equal parent.message + ' ' + message, @context1.all_message
+    assert_equal nana.message + ' ' + parent.message + ' ' + message, @context1.all_message
   end
   
-  def test_setups_with_parent
+  def test_setups_with_parents
+    pops = GUnit::Context.new
+    pops.setups = [GUnit::Setup.new, GUnit::Setup.new]
     parent = GUnit::Context.new
     parent.setups = [GUnit::Setup.new, GUnit::Setup.new]
+    parent.parent = pops
     setups = [GUnit::Setup.new, GUnit::Setup.new]
     @context1.parent = parent
     @context1.setups = setups
-    assert_equal parent.setups  + setups, @context1.all_setups
+    assert_equal pops.setups + parent.setups + setups, @context1.all_setups
   end
   
-  def test_teardowns_with_parent
+  def test_teardowns_with_parents
+    pops = GUnit::Context.new
+    pops.teardowns = [GUnit::Teardown.new, GUnit::Teardown.new]
     parent = GUnit::Context.new
     parent.teardowns = [GUnit::Teardown.new, GUnit::Teardown.new]
+    parent.parent = pops
     teardowns = [GUnit::Teardown.new, GUnit::Teardown.new]
     @context1.parent = parent
     @context1.teardowns = teardowns
-    assert_equal parent.teardowns  + teardowns, @context1.all_teardowns
+    assert_equal pops.teardowns + parent.teardowns + teardowns, @context1.all_teardowns
   end
   
   # Context.new('my fixtures')

data/test/unit/exercise_test.rb

@@ -0,0 +1,100 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+# class MyClassTest < GUnit::TestCase
+#   exercise "Some fixtures should be created here"
+#   
+#   context "An instance of MyClass"
+#     setup "a Foo with a name" do
+#       @foo = Foo.new("a foo")
+#     end
+#     exercise "renamed" do
+#       @foo.rename("the foo")
+#     end
+#   end
+# end
+
+class GUnit::ExerciseTest < Test::Unit::TestCase
+  
+  def setup
+    @exercise1 = GUnit::Exercise.new
+  end
+  
+  def test_it_is_a_exercise
+    assert @exercise1.is_a?(GUnit::Exercise)
+  end
+  
+  def test_has_default_message
+    assert_not_nil @exercise1.message
+  end
+  
+  def test_message_setter
+    message = "Exercise some code"
+    @exercise1.message = message
+    assert_equal message, @exercise1.message
+  end
+  
+  # Exercise.new('some feature')
+  def test_initialize_with_one_arg
+    message = 'some feature'
+    @exercise2 = GUnit::Exercise.new(message)
+    assert @exercise2.message === message
+  end
+  
+  # Exercise.new('some feature'){ @foo = "bar" }
+  def test_initialize_with_one_arg_and_block
+    message = 'some feature'
+    task    = (@foo = "bar")
+    @exercise2 = GUnit::Exercise.new(message) { (@foo = "bar") }
+    assert message === @exercise2.message
+    assert task === @exercise2.task.call
+  end
+  
+  def test_run_with_task_called_returns_true
+    @exercise1.task = Proc.new { true }
+    response = @exercise1.run
+    assert response === true
+  end
+  
+  def test_run_with_task_called_returns_false
+    @exercise1.task = Proc.new { false }
+    response = @exercise1.run
+    assert response === true
+  end
+  
+  def test_run_with_task_is_false
+    @exercise1.task = false
+    response = @exercise1.run
+    assert response === true
+  end
+  
+  def test_run_with_task_is_nil
+    @exercise1.task = nil
+    response = @exercise1.run
+    assert response === true
+  end
+  
+  def test_run_with_assertion_failure_exception
+    @exercise1.task = lambda { raise GUnit::AssertionFailure }
+    response = @exercise1.run
+    assert response.is_a?(GUnit::TestResponse)
+    assert response.is_a?(GUnit::FailResponse)
+  end
+  
+  def test_run_with_random_exception
+    @exercise1.task = lambda { raise 'Boom' }
+    response = @exercise1.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")
+    @exercise1.task = Proc.new { instance_variable_set("@foo", "zip") }
+    @exercise1.run
+    assert_equal "bar", obj.instance_variable_get("@foo")
+    @exercise1.run(obj)
+    assert_equal "zip", obj.instance_variable_get("@foo")
+  end
+  
+end

data/test/unit/test_case_test.rb

@@ -97,6 +97,15 @@ class GUnit::TestCaseTest < Test::Unit::TestCase
     assert_equal "bar", @my_test_case1.instance_variable_get("@foo")
   end
   
+  def test_run_runs_exercise
+    MyClassTest.setup { @foo = "abc" }
+    MyClassTest.exercise { @foo.replace "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" }
@@ -166,16 +175,19 @@ class GUnit::TestCaseTest < Test::Unit::TestCase
   def test_setup_and_teardown_inside_context_creates_context_with_setup_and_teardown
     context_msg   = "In some context"
     setup_msg     = "Given this"
+    exercise_msg  = "Doing this"
     teardown_msg  = "Housekeeping"
     verify_msg    = "This should be the case B"
     MyClassTest.context(context_msg) do
       setup(setup_msg) { @foo = "abc" }
+      exercise(exercise_msg) { @foo.replace "xyz" }
       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 exercise_msg, context.exercise.message
     assert_equal teardown_msg, context.teardowns.last.message
   end
   
@@ -198,4 +210,72 @@ class GUnit::TestCaseTest < Test::Unit::TestCase
     assert context.is_a?(GUnit::Context)
   end
   
+  def test_run_runs_contexts_setups
+    setup = GUnit::Setup.new { @foo = @foo.nil? ? 1 : @foo+1 }
+    pops = GUnit::Context.new
+    pops.setups = [setup, setup]
+    parent = GUnit::Context.new
+    parent.setups = [setup, setup]
+    parent.parent = pops
+    context1 = GUnit::Context.new
+    context1.setups = [setup, setup]
+    context1.parent = parent
+    method_name = "test_one"
+    @my_test_case1 = MyClassTest.new(method_name)
+    @my_test_case1.stubs(:context).returns(context1)
+    @my_test_case1.run
+    assert_equal 6, @my_test_case1.instance_variable_get("@foo")
+  end
+  
+  def test_run_runs_context_exercise_only
+    exercise = GUnit::Exercise.new { @foo = @foo.nil? ? 1 : @foo+1 }
+    pops = GUnit::Context.new
+    pops.exercise = exercise
+    parent = GUnit::Context.new
+    parent.exercise = exercise
+    parent.parent = pops
+    context1 = GUnit::Context.new
+    context1.exercise = exercise
+    context1.parent = parent
+    method_name = "test_one"
+    @my_test_case1 = MyClassTest.new(method_name)
+    @my_test_case1.stubs(:context).returns(context1)
+    @my_test_case1.run
+    assert_equal 1, @my_test_case1.instance_variable_get("@foo")
+  end
+  
+  def test_run_runs_contexts_teardowns
+    teardown = GUnit::Teardown.new { @foo = @foo.nil? ? 1 : @foo+1 }
+    pops = GUnit::Context.new
+    pops.teardowns = [teardown, teardown]
+    parent = GUnit::Context.new
+    parent.teardowns = [teardown, teardown]
+    parent.parent = pops
+    context1 = GUnit::Context.new
+    context1.teardowns = [teardown, teardown]
+    context1.parent = parent
+    method_name = "test_one"
+    @my_test_case1 = MyClassTest.new(method_name)
+    @my_test_case1.stubs(:context).returns(context1)
+    @my_test_case1.run
+    assert_equal 6, @my_test_case1.instance_variable_get("@foo")
+  end
+  
+  def test_run_runs_contexts_teardowns_in_reverse_order
+    teardown = GUnit::Teardown.new { @foo = @foo.nil? ? 1 : @foo+1 }
+    last_teardown = GUnit::Teardown.new { @foo = -1 }
+    pops = GUnit::Context.new
+    pops.teardowns = [last_teardown, teardown]
+    parent = GUnit::Context.new
+    parent.teardowns = [teardown, teardown]
+    parent.parent = pops
+    context1 = GUnit::Context.new
+    context1.teardowns = [teardown, teardown]
+    context1.parent = parent
+    method_name = "test_one"
+    @my_test_case1 = MyClassTest.new(method_name)
+    @my_test_case1.stubs(:context).returns(context1)
+    @my_test_case1.run
+    assert_equal -1, @my_test_case1.instance_variable_get("@foo")
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: GUnit
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors: 
 - Greg Sterndale
@@ -50,6 +50,7 @@ files:
 - test/test_helper.rb
 - test/unit/assertions_test.rb
 - test/unit/context_test.rb
+- test/unit/exercise_test.rb
 - test/unit/fail_response_test.rb
 - test/unit/proc_extensions_test.rb
 - test/unit/setup_test.rb
@@ -91,6 +92,7 @@ test_files:
 - test/test_helper.rb
 - test/unit/assertions_test.rb
 - test/unit/context_test.rb
+- test/unit/exercise_test.rb
 - test/unit/fail_response_test.rb
 - test/unit/proc_extensions_test.rb
 - test/unit/setup_test.rb