handoff 0.2.0 → 1.0.0

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2007 John D. Hume
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -9,5 +9,5 @@ As of 0.2.0, Handoff no longer depends on Mocha and Stubba.
 
 Here's example_test.rb to give you an idea of what you can do:
 
- :include: test/example_test.rb
+ :include: examples/example_test.rb
 

data/examples/bad_handoffs_test.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test/test_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../lib/handoff')
+require 'forwardable'
+
+class BadDelegator
+  extend Forwardable
+  def_delegators :a, :foo, :bar
+  def_delegators :b, :foo, :bar
+  def a; Struct.new(:foo, :bar).new; end
+  def b; Struct.new(:foo, :bar).new; end
+end
+
+class BadHandoffsTest < Test::Unit::TestCase
+  
+  def test_with_multiple_redefined_handoffs
+    bad = BadDelegator.new
+    assert_handoff.from(bad).to(:a).for(:foo, :bar)
+  end
+  
+  def test_with_multiple_unimplemented_handoffs
+    assert_handoff.from(BadDelegator.new).to(:a).for(:baz, :bat)
+  end
+  
+end

data/lib/handoff.rb

@@ -9,11 +9,9 @@ module Handoff
   
   TEARDOWN_ALIAS = :teardown_before_handoff_rewrite
   
-  # Creates an Assertion, handing a it a mock named 'handoff delegate' on which
-  # expectations will be set.
   def assert_handoff
     ensure_handoff_teardown_defined
-    a = Handoff::Assertion.new(self)
+    a = Handoff::Assertion.new(self, caller)
     handoff_assertions << a
     a
   end
@@ -44,5 +42,5 @@ module Handoff
 end
 
 class Test::Unit::TestCase
-  include Handoff unless ancestors.include?(Handoff)
+  include Handoff
 end

data/lib/handoff/argument_normalizer.rb

@@ -1,15 +1,15 @@
 module Handoff
   # Handoff internal.
   module ArgumentNormalizer
-  
-    def to_method_map
-      return first if size == 1 && first.respond_to?(:each_pair)
-      to_self_referencing_hash
+    module_function
+    def to_method_map args
+      return args.first if args.size == 1 && args.first.respond_to?(:each_pair)
+      to_self_referencing_hash args
     end
     
-    def to_self_referencing_hash
+    def to_self_referencing_hash args
       hash = Hash.new
-      each {|method_symbol| hash[method_symbol] = method_symbol}
+      args.each {|method_symbol| hash[method_symbol] = method_symbol}
       hash
     end
   

data/lib/handoff/assertion.rb

@@ -10,13 +10,11 @@ module Handoff
   # * +to+, 
   # * +for+, +for_method+ or +for_methods+, and
   # * (optionally) +with+ or +with_arguments+.
-  class Assertion < Struct.new(:test)
+  class Assertion < Struct.new(:test, :backtrace)
     
     # :stopdoc:
-    
     attr_reader :method_map
     attr_reader :delegator
-    private :method_map, :delegator
     
     # :startdoc:
     
@@ -48,7 +46,7 @@ module Handoff
     # +args+:: symbols representing the delegating methods if they are not renamed, or
     #          a Hash mapping methods in the delegating class to methods in the delegate.
     def for_methods(*args)
-      @method_map = args.extend(ArgumentNormalizer).to_method_map
+      @method_map = ArgumentNormalizer.to_method_map(args)
       self
     end
     alias for_method for_methods
@@ -56,6 +54,7 @@ module Handoff
     
     def with_arguments *args
       @args = args
+      self
     end
     alias with with_arguments
     
@@ -70,18 +69,23 @@ module Handoff
     def conduct
       validate_sufficiently_specified
       method_map.each do |delegating_method, target_method|
-        mock_delegate = VerifyingDelegate.new(target_method, @args||[])
+        verifying_delegate = VerifyingDelegate.new(target_method, @args||[])
         accessor = @delegate_accessor
         (class << @delegator; self; end).class_eval do
-          define_method(accessor) { mock_delegate }
+          define_method(accessor) { verifying_delegate }
         end
         send_args = [delegating_method]
-        if @args
-          send_args << @args
-          send_args.flatten!
-        end
+        send_args.concat @args if @args
         actual_return = @delegator.send *send_args
-        test.assert_equal mock_delegate.happy_return, actual_return
+        test.instance_eval {add_assertion}
+        expected_return = verifying_delegate.happy_return
+        if expected_return != actual_return
+          backtrace = self.backtrace
+          delegate_accessor = @delegate_accessor
+          test.instance_eval do
+            add_failure "`#{delegating_method}' didn't delegate to `#{delegate_accessor}.#{target_method}'", backtrace
+          end
+        end
       end
     end
     

data/lib/handoff/verifying_delegate.rb

@@ -4,14 +4,15 @@ module Handoff
       @target_method = target_method
       (class << self; self; end).class_eval do
         define_method target_method do |*actual_args|
+          raise 'called twice' if @returned
           raise( ArgumentError, "expected arguments: '#{expected_args}' but got '#{actual_args}'") unless expected_args == actual_args
-          happy_return
+          @returned = true and happy_return
         end
       end
     end
     
     def happy_return
-      "return value from #{to_s}"
+      "handoff return value from #{to_s}"
     end
     
     def method_missing method, *args

data/test/handoff/argument_normalizer_test.rb

@@ -3,21 +3,19 @@ require File.expand_path(File.dirname(__FILE__) + '/../../lib/handoff/argument_n
 
 module Handoff
   class ArgumentNormalizerTest < Test::Unit::TestCase
-  
+    
     test "should return hash at front of one element array" do
       hash = {}
-      assert_same hash, [hash].extend(ArgumentNormalizer).to_method_map
+      assert_same hash, ArgumentNormalizer.to_method_map([hash])
     end
     
     test "should return self referencing hash for array of symbols" do
-      args = [:bar, :foo].extend(ArgumentNormalizer)
-      assert_equal({:foo => :foo, :bar => :bar}, args.to_method_map)
+      assert_equal({:foo => :foo, :bar => :bar}, ArgumentNormalizer.to_method_map([:bar, :foo]))
     end
     
     test "should return self referencing hash for one element array with symbol" do
-      args = [:foo].extend(ArgumentNormalizer)
-      assert_equal({:foo => :foo}, args.to_method_map)
+      assert_equal({:foo => :foo}, ArgumentNormalizer.to_method_map([:foo]))
     end
-  
+    
   end
 end

data/test/handoff/assertion_test.rb

@@ -9,84 +9,63 @@ module Handoff
     
     test 'should construct instance to test and return self when from_any is called' do
       assertion = Assertion.new(nil)
-      assert_same assertion, assertion.from_any(mock('class under test', :new => nil))
+      assert_same assertion, assertion.from_any(mock('class under test', :new => :created_object))
     end
     
-    test 'conduct should pass with one Test::Unit assertion if delegator does its job' do
-      delegator = Class.new do
-        def foo; delegate.foo; end
-        def delegate; nil; end
-      end.new
-      assertion = Assertion.new(mock(:assert_equal => nil))
-      assertion.from(delegator).to(:delegate).for(:foo)
+    test 'conduct adds failure for bad return value' do
+      test_case = mock
+      delegator = mock
+      verifying_delegate = mock
+      
+      assertion = Assertion.new(test_case, :backtrace).from(delegator).to(:delegate).for(:method)
+      
+      VerifyingDelegate.expects(:new).returns(verifying_delegate)
+      delegator.expects(:method).returns("something other than the verifying delegate's happy_return")
+      verifying_delegate.expects(:happy_return).returns(:the_expected_return_value)
+      test_case.expects(:add_assertion)
+      test_case.expects(:add_failure).with("`method' didn't delegate to `delegate.method'", :backtrace)
+      
       assertion.conduct
     end
     
-    # test 'should create expectations on mock_delegate and object under test upon conduct' do
-    #   cut = Class.new do
-    #     extend Forwardable
-    #     def_delegator :asdf, :meth
-    #     attr_reader :asdf
-    #   end
-    #   mock_delegate = mock
-    #   object_under_test = cut.new
-    #   assertion = Assertion.new(mock_delegate).from(object_under_test).to(:asdf).for_method(:meth)
-    #   assertion.conduct
-    #   assert_equal :asdf, object_under_test.mocha.expectations.first.method_name
-    #   assert_equal :meth, mock_delegate.expectations.last.method_name
-    # end
-    # 
-    # test 'should create mock_delegate expectation with arguments when supplied' do
-    #   delegator = Class.new do
-    #     extend Forwardable
-    #     def_delegator :delegate, :meth
-    #     attr_reader :delegate
-    #   end.new
-    #   assertion = Assertion.new(mock_delegate = mock).from(delegator).to(:delegate).for(:meth)
-    #   assertion.with('arg1', :arg2, 3)
-    #   assertion.conduct
-    #   assert_true mock_delegate.expectations.first.match?(:meth, 'arg1', :arg2, 3)
-    #   assert_false mock_delegate.expectations.first.match?(:meth)
-    #   assert_false mock_delegate.expectations.first.match?(:meth, 'arg1')
-    # end
-    # 
-    # { 
-    #   :with => lambda {|assertion| assertion.with},
-    #   :with_no_arguments => lambda {|assertion| assertion.with_no_arguments}
-    # }.each_pair do |method, proc|
-    #   test "should force no args when #{method} is used to specify none" do
-    #     delegator = Class.new do
-    #       extend Forwardable
-    #       def_delegator :delegate, :meth
-    #       attr_reader :delegate
-    #     end.new
-    #     assertion = Assertion.new(mock_delegate = mock).from(delegator).to(:delegate).for(:meth)
-    #     proc.call(assertion)
-    #     assertion.conduct
-    #     assert_true mock_delegate.expectations.first.match?(:meth)
-    #     assert_false mock_delegate.expectations.first.match?(:meth, 'arg1')
-    #   end
-    # end
-    # 
-    # test 'should allow for args or no args if nothing specified' do
-    #   delegator = Class.new do
-    #     extend Forwardable
-    #     def_delegator :delegate, :meth
-    #     attr_reader :delegate
-    #   end.new
-    #   assertion = Assertion.new(mock_delegate = mock).from(delegator).to(:delegate).for(:meth)
-    #   assertion.conduct
-    #   assert_true mock_delegate.expectations.first.match?(:meth)
-    #   assert_true mock_delegate.expectations.first.match?(:meth, 'arg1')
-    # end
+    test 'for each method, conduct attaches verifying delegate to delegator and invokes method' do
+      test_case = mock
+      delegator = mock
+      verifying_delegate1 = mock
+      verifying_delegate2 = mock
+      method_map = mock
+      
+      assertion = Assertion.new(test_case).from(delegator).to(:delegate).for(:method1 => :target_method1, :method2 => :target_method2).with('the args')
+      VerifyingDelegate.expects(:new).with(:target_method1, ['the args']).returns(verifying_delegate1)
+      delegator.expects(:method1).with('the args').returns(:return_value1)
+      verifying_delegate1.expects(:happy_return).returns(:return_value1)
+      test_case.expects(:add_assertion)
+      VerifyingDelegate.expects(:new).with(:target_method2, ['the args']).returns(verifying_delegate2)
+      delegator.expects(:method2).with('the args').returns(:return_value2)
+      verifying_delegate2.expects(:happy_return).returns(:return_value2)
+      test_case.expects(:add_assertion)
+      
+      assertion.conduct
+    end
     
-    test 'validates presence of delegator, delegate accessor, and delegating methods' do
-      assertion = Assertion.new(mock).from(nil).to(:asdf).for_method(:meth)
-      assert_raises(UsageError) { assertion.conduct }
+    test 'converts method list or hash into method map with ArgumentNormalizer' do
+      ArgumentNormalizer.expects(:to_method_map).with([:args]).returns(:the_method_map)
       
-      assertion = Assertion.new(mock).from("whatever").to(nil).for_method(:meth)
+      assertion = Assertion.new(mock).for_methods(:args)
+      assert_equal :the_method_map, assertion.method_map
+    end
+    
+    test 'validates presence of delegator' do
+      assertion = Assertion.new(mock).to(:asdf).for_method(:meth)
       assert_raises(UsageError) { assertion.conduct }
-      
+    end
+    
+    test 'validates presence of delegate accessor' do
+      assertion = Assertion.new(mock).from("whatever").for_method(:meth)
+      assert_raises(UsageError) { assertion.conduct }
+    end
+    
+    test 'validates presence of delegating methods' do
       assertion = Assertion.new(mock).from("whatever").to(:asdf)
       assert_raises(UsageError) { assertion.conduct }
     end

data/test/handoff/verifying_delegate_test.rb

@@ -5,7 +5,7 @@ module Handoff
   class VerifyingDelegateTest < Test::Unit::TestCase
     test "happy_return value" do
       d = VerifyingDelegate.new(:foo, [])
-      assert_equal "return value from #{d.to_s}", d.happy_return
+      assert_equal "handoff return value from #{d.to_s}", d.happy_return
     end
     
     test 'responds to target method with happy_return value' do
@@ -23,6 +23,12 @@ module Handoff
       assert_raises(ArgumentError) { d.foo }
     end
     
+    test 'raises if target invoked twice' do
+      d = VerifyingDelegate.new(:foo, [])
+      d.foo
+      assert_raises(RuntimeError) { d.foo }
+    end
+    
     test 'raises NoMethodError with helpful message if wrong method is invoked' do
       d = VerifyingDelegate.new(:foo, [])
       begin

data/test/handoff_test.rb

@@ -4,13 +4,11 @@ require 'mocha'
 require File.expand_path(File.dirname(__FILE__) + '/../lib/handoff')
 
 class HandoffTest < Test::Unit::TestCase
-  test 'should conduct each assertion in conduct_and_clear_handoffs' do
+  test 'conducts each assertion in conduct_and_clear_handoffs' do
     handoff_assertions << assertion1 = mock(:conduct => nil)
     handoff_assertions << assertion2 = mock(:conduct => nil)
     conduct_and_clear_handoffs
     assert_true handoff_assertions.empty?
-    assertion1.verify
-    assertion2.verify
   end
   
   def blank_test_case

data/test/test_helper_test.rb

@@ -7,4 +7,8 @@ class TestHelperTest < Test::Unit::TestCase
     assert_raises(Test::Unit::AssertionFailedError) { assert_true 'foo' }
   end
   
+  test "assert_false fails on nil" do
+    assert_raises(Test::Unit::AssertionFailedError) { assert_false nil }
+  end
+  
 end

metadata

@@ -3,9 +3,9 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: handoff
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
-date: 2007-05-18 00:00:00 -07:00
-summary: Handoff is a fluent interface for making test assertions about delegation.
+  version: 1.0.0
+date: 2007-10-26 00:00:00 -04:00
+summary: Handoff is a fluent interface for making Test::Unit assertions about delegation.
 require_paths: 
 - lib
 email: ""
@@ -35,9 +35,11 @@ files:
 - lib/handoff/assertion.rb
 - lib/handoff/usage_error.rb
 - lib/handoff/verifying_delegate.rb
+- examples/bad_handoffs_test.rb
+- examples/example_test.rb
 - README
+- LICENSE
 test_files: 
-- test/example_test.rb
 - test/handoff_test.rb
 - test/test_helper_test.rb
 - test/handoff/argument_normalizer_test.rb
@@ -47,6 +49,7 @@ rdoc_options: []
 
 extra_rdoc_files: 
 - README
+- LICENSE
 executables: []
 
 extensions: []