test_unit-given 0.1.1 → 0.9.0

data/README.rdoc

@@ -111,6 +111,50 @@ Finally, you can re-use blocks, and use And to create richer expressions:
       }
     end
 
+=== What about mocks?
+
+Mocks create an interesting issue, because the "assertions" are the mock expectations you setup before you call the method under test.  This means that the "then" side of things is out of order.
+
+    class CircleTest < Test::Unit::Given::TestCase
+      test_that "our external diameter service is being used" do
+        Given {
+          @diameter_service = mock()
+          @diameter_service.expects(:get_diameter).with(10).returns(400)
+          @cirlce = Circle.new(10,@diameter_service)
+        }
+        When  {
+          @diameter = @cirlce.diameter
+        }
+        Then {
+          // assume mocks were called
+        }
+      end
+    end
+
+This is somewhat confusing.  We could solve it like so:
+
+    class CircleTest < Test::Unit::Given::TestCase
+      test_that "our external diameter service is being used" do
+        Given {
+          @diameter_service = mock()
+        }
+        When mocks_are_called
+        Then {
+          @diameter_service.expects(:get_diameter).with(10).returns(400)
+        }
+        Given {
+          @cirlce = Circle.new(10,@diameter_service)
+        }
+        When  {
+          @diameter = @cirlce.diameter
+        }
+        Then mocks_shouldve_been_called
+      end
+    end
+
+Although both <tt>mocks_are_called</tt> and <tt>mocks_shouldve_been_called</tt> are no-ops,
+they allow our tests to be readable and make clear what the assertions are that we are making.
+
 === What about block-based assertions, like +assert_raises+
 
     class CircleTest < Test::Unit::Given::TestCase

data/lib/test/unit/given/simple.rb

@@ -94,6 +94,76 @@ module Test
           Given(existing_block,&block)
         end
 
+        # Public: Continue the previous Given/When/Then in a new block.  The reason
+        # you might do this is if you wanted to use the existing block form of a
+        # Given/When/Then, but also need to do something custom, and that custom thing
+        # contradicts or overrides the flow, so an "And" wouldn't read properly.  This allows you to 
+        # write your test more fluently.
+        #
+        # existing_block - a callable object (e.g. a Proc) that will be called immediately
+        #                  by this Then.  If nil, &block is expected to be passed
+        # block          - a block given to this call that will be executed immediately
+        #                  by this Then.  If existing_block is non-nil, this is ignored
+        #
+        # Examples
+        #     
+        #     given_block = Given {
+        #       @options = {
+        #         :foo => 'bar',
+        #         :quux => 'baz',
+        #       }
+        #     }
+        #     Given then_block
+        #     And {
+        #       @name = 'Foo'
+        #     }
+        #     But {
+        #       @options[:quux] = 'BAZ'
+        #     }
+        #
+        # Returns the block that was executed
+        def But(existing_block=nil,&block)
+          Given(existing_block,&block)
+        end
+
+        # Public: Used to make clear the structure of tests using mocks.
+        # This returns a no-op, and is intended to be used with a "When"
+        # to delineate the creation of a mock in a Given, and the 
+        # expectations of a mock in a "Then"
+        #
+        # Example:
+        #
+        #     Given {
+        #       @google = mock()
+        #     }
+        #     When mocks_are_called
+        #     Then {
+        #       @google.expects(:search).with('foo').returns('bar')
+        #     }
+        #     Given {
+        #       @my_search = Search.new(@google)
+        #     }
+        #     When {
+        #       @result = @my_search.find('foo')
+        #     }
+        #     Then {
+        #       assert_equal 'Found bar',@result
+        #     }
+        #     And mocks_shouldve_been_called
+        def mocks_are_called
+          lambda {}
+        end
+
+        # Similar to #mocks_are_called, this is used to make clear what
+        # you are testing and what the assertions are.  Since many Ruby mock
+        # frameworks do not require an explicit "verify" step, you often have tests
+        # that have no explicit asserts, the assertions being simply that the mocks were called
+        # as expected.  This step, which is a no-op, allows you to document that you are 
+        # expecting mocks to be called. See the example in #mocks_are_called for usage.
+        def mocks_shouldve_been_called
+          lambda {}
+        end
+
         private
 
         def call_block_param_or_block_given(existing_block,&block)

data/lib/test/unit/given/version.rb

@@ -1,7 +1,7 @@
 module Test
   module Unit
     module Given
-      VERSION = "0.1.1"
+      VERSION = "0.9.0"
     end
   end
 end

data/test/test_simple_given.rb

@@ -9,6 +9,7 @@ class TestSimpleGiven < Test::Unit::Given::TestCase
     }
     And {
       @y = nil
+      @z = 10
     }
     When {
       @x = 4
@@ -16,12 +17,28 @@ class TestSimpleGiven < Test::Unit::Given::TestCase
     And {
       @y = 10
     }
+    But {
+      @z # not assigned
+    }
     Then {
       assert_equal 4,@x
     }
     And {
       assert_equal 10,@y
     }
+    But {
+      assert_equal 10,@z
+    }
+  end
+
+  def test_mock_support
+    Given { @x = 4 }
+    When mocks_are_called
+    Then { }
+    Given { @y = 4 }
+    When { @y = 10 }
+    Then { assert_equal 10,@y }
+    And mocks_shouldve_been_called
   end
 
   def test_cannot_use_locals

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: test_unit-given
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.9.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-02 00:00:00.000000000Z
+date: 2011-11-19 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdoc
-  requirement: &70217514612460 !ruby/object:Gem::Requirement
+  requirement: &70252391815780 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70217514612460
+  version_requirements: *70252391815780
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70217514612040 !ruby/object:Gem::Requirement
+  requirement: &70252391815360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70217514612040
+  version_requirements: *70252391815360
 - !ruby/object:Gem::Dependency
   name: simplecov
-  requirement: &70217514611620 !ruby/object:Gem::Requirement
+  requirement: &70252391814940 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,7 +43,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70217514611620
+  version_requirements: *70252391814940
 description: We don't need no stinkin' RSpec!  Get all the fluency you want in your
   Test::Unit tests, with no magic required, using straight Ruby syntax
 email: