handoff 0.1.0 → 0.2.0

data/README

@@ -3,7 +3,9 @@ stdlib module +Forwardable+ makes implementing delegation simple and readable.
 Handoff is intended to make the code to test it just as simple and 
 readable.
 
-Handoff depends on Mocha and Stubba (http://mocha.rubyforge.org).
+You can install the latest gem using <code>gem install handoff</code> or download the .gem file from http://rubyforge.org/projects/handoff.
+
+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:
 

data/lib/handoff.rb

@@ -1,4 +1,4 @@
-require 'handoff/assertion'
+require File.expand_path(File.dirname(__FILE__) + '/handoff/assertion')
 
 # +require+ (or +require_gem+) 'handoff' and #assert_handoff can 
 # be called from any Test::Unit::TestCase test method to create 
@@ -7,14 +7,28 @@ require 'handoff/assertion'
 # After defining Handoff, this file includes it in Test::Unit::TestCase.
 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
-    a = Handoff::Assertion.new(self.mock('handoff delegate'))
+    ensure_handoff_teardown_defined
+    a = Handoff::Assertion.new(self)
     handoff_assertions << a
     a
   end
   
+  def ensure_handoff_teardown_defined
+    return if respond_to?(TEARDOWN_ALIAS)
+    class << self
+      alias_method TEARDOWN_ALIAS, :teardown
+      def teardown
+        conduct_and_clear_handoffs
+        send TEARDOWN_ALIAS
+      end
+    end
+  end
+  
   def handoff_assertions
     @handoff_assertions ||= []
   end
@@ -27,12 +41,6 @@ module Handoff
     end
   end
   
-  def self.included(base)
-    base.class_eval do
-      add_teardown_method :conduct_and_clear_handoffs
-    end
-  end
-  
 end
 
 class Test::Unit::TestCase

data/lib/handoff/assertion.rb

@@ -1,5 +1,6 @@
-require 'handoff/argument_normalizer'
-require 'handoff/usage_error'
+require File.expand_path(File.dirname(__FILE__) + '/argument_normalizer')
+require File.expand_path(File.dirname(__FILE__) + '/usage_error')
+require File.expand_path(File.dirname(__FILE__) + '/verifying_delegate')
 
 module Handoff
   # This is where the fluent stuff is.
@@ -9,7 +10,7 @@ module Handoff
   # * +to+, 
   # * +for+, +for_method+ or +for_methods+, and
   # * (optionally) +with+ or +with_arguments+.
-  class Assertion
+  class Assertion < Struct.new(:test)
     
     # :stopdoc:
     
@@ -17,10 +18,6 @@ module Handoff
     attr_reader :delegator
     private :method_map, :delegator
     
-    def initialize mock_delegate
-      @mock_delegate = mock_delegate
-    end
-    
     # :startdoc:
     
     # Creates an instance of +class_under_test+ with no arguments and uses it
@@ -64,7 +61,6 @@ module Handoff
     
     # Specifies that the assertion should pass no arguments to the delegating method and 
     # require that no arguments are sent to the target method.
-    # Equivalent to calling +with_arguments+ with no arguments.
     def with_no_arguments
       with_arguments
     end
@@ -73,19 +69,19 @@ module Handoff
     
     def conduct
       validate_sufficiently_specified
-      @delegator.expects(@delegate_accessor).at_least_once.returns(@mock_delegate)
-      expected_returns = {}
-      method_map.each_pair do |delegating_method, target|
-        expected_returns[delegating_method] = "#{delegating_method.to_s}_return"
-        expectation = @mock_delegate.expects(target).returns(expected_returns[delegating_method])
-        expectation.with(*@args) unless @args.nil?
-      end
-      method_map.each_pair do |delegating_method, target|
-        send_args = [delegating_method, @args].flatten
-        actual = delegator.send(*send_args)
-        unless actual.equal? expected_returns[delegating_method]
-          raise "expected #{delegating_method.to_s} to return #{expected_returns[delegating_method]}, but was #{actual}"
+      method_map.each do |delegating_method, target_method|
+        mock_delegate = VerifyingDelegate.new(target_method, @args||[])
+        accessor = @delegate_accessor
+        (class << @delegator; self; end).class_eval do
+          define_method(accessor) { mock_delegate }
         end
+        send_args = [delegating_method]
+        if @args
+          send_args << @args
+          send_args.flatten!
+        end
+        actual_return = @delegator.send *send_args
+        test.assert_equal mock_delegate.happy_return, actual_return
       end
     end
     
@@ -95,6 +91,7 @@ module Handoff
       raise UsageError, "Delegate accessor must be specified with 'to'" unless @delegate_accessor
       raise UsageError, "Delegating methods must be specified with 'for_method' or 'for_methods'" unless @method_map
     end
+    
     # :startdoc:
   end
 end

data/lib/handoff/verifying_delegate.rb

@@ -0,0 +1,21 @@
+module Handoff
+  class VerifyingDelegate
+    def initialize target_method, expected_args
+      @target_method = target_method
+      (class << self; self; end).class_eval do
+        define_method target_method do |*actual_args|
+          raise( ArgumentError, "expected arguments: '#{expected_args}' but got '#{actual_args}'") unless expected_args == actual_args
+          happy_return
+        end
+      end
+    end
+    
+    def happy_return
+      "return value from #{to_s}"
+    end
+    
+    def method_missing method, *args
+      raise NoMethodError, "Expected handoff to method `#{@target_method}', but `#{method}' was called"
+    end
+  end
+end

data/test/example_test.rb

@@ -19,12 +19,8 @@ class Foo
 end
 
 require 'test/unit'
-require 'rubygems'
 
-require 'mocha' # You need to require mocha and stubba in your test.
-require 'stubba' # ditto
-
-require File.dirname(__FILE__) + '/../lib/handoff' # I require it this way because I don't want the installed gem.
+require File.expand_path(File.dirname(__FILE__) + '/../lib/handoff') # I require it this way because I don't want the installed gem.
 # require 'handoff' # This is how you'd require handoff (or do require_gem w/ a version).
 
 class ExampleTest < Test::Unit::TestCase

data/test/handoff/argument_normalizer_test.rb

@@ -1,20 +1,20 @@
-require 'test/unit'
-require File.dirname(__FILE__) + '/../../lib/handoff/argument_normalizer'
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../../lib/handoff/argument_normalizer')
 
 module Handoff
   class ArgumentNormalizerTest < Test::Unit::TestCase
   
-    def test_should_return_hash_at_front_of_one_element_array
+    test "should return hash at front of one element array" do
       hash = {}
       assert_same hash, [hash].extend(ArgumentNormalizer).to_method_map
     end
     
-    def test_should_return_self_referencing_hash_for_array_of_symbols
+    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)
     end
     
-    def test_should_return_self_referencing_hash_for_one_element_array_with_symbol
+    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)
     end

data/test/handoff/assertion_test.rb

@@ -1,6 +1,5 @@
-require 'test/unit'
-require File.dirname(__FILE__) + '/../test_helper'
-require File.dirname(__FILE__) + '/../../lib/handoff/assertion'
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../../lib/handoff/assertion')
 require 'rubygems'
 require 'mocha'
 require 'stubba'
@@ -13,63 +12,73 @@ module Handoff
       assert_same assertion, assertion.from_any(mock('class under test', :new => nil))
     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
+    test 'conduct should pass with one Test::Unit assertion if delegator does its job' do
       delegator = Class.new do
-        extend Forwardable
-        def_delegator :delegate, :meth
-        attr_reader :delegate
+        def foo; delegate.foo; end
+        def delegate; nil; end
       end.new
-      assertion = Assertion.new(mock_delegate = mock).from(delegator).to(:delegate).for(:meth)
-      assertion.with('arg1', :arg2, 3)
+      assertion = Assertion.new(mock(:assert_equal => nil))
+      assertion.from(delegator).to(:delegate).for(:foo)
       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 '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 'validates presence of delegator, delegate accessor, and delegating methods' do
       assertion = Assertion.new(mock).from(nil).to(:asdf).for_method(:meth)

data/test/handoff/verifying_delegate_test.rb

@@ -0,0 +1,36 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../../lib/handoff/verifying_delegate')
+
+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
+    end
+    
+    test 'responds to target method with happy_return value' do
+      d = VerifyingDelegate.new(:foo, [])
+      assert_equal d.happy_return, d.foo
+    end
+    
+    test 'happy if args match' do
+      d = VerifyingDelegate.new(:foo, [1])
+      assert_equal d.happy_return, d.foo(1)
+    end
+    
+    test 'raises if args dont match' do
+      d = VerifyingDelegate.new(:foo, [1])
+      assert_raises(ArgumentError) { d.foo }
+    end
+    
+    test 'raises NoMethodError with helpful message if wrong method is invoked' do
+      d = VerifyingDelegate.new(:foo, [])
+      begin
+        d.foob
+        fail
+      rescue NoMethodError => e
+        assert_equal "Expected handoff to method `foo', but `foob' was called", e.message
+      end
+    end
+  end
+end

data/test/handoff_test.rb

@@ -1,26 +1,9 @@
-require File.dirname(__FILE__) + '/test_helper'
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
 require 'rubygems'
 require 'mocha'
-require 'stubba'
-require File.dirname(__FILE__) + '/../lib/handoff'
+require File.expand_path(File.dirname(__FILE__) + '/../lib/handoff')
 
 class HandoffTest < Test::Unit::TestCase
-  test 'should create a mock named "handoff delegate" and hand it to a new Assertion' do
-    given_name = nil
-    def self.mock name
-      assert_equal 'handoff delegate', name
-      :mock_return
-    end
-    Assertion.expects(:new).with(:mock_return).returns(:new_assertion)
-    assert_equal :new_assertion, assert_handoff
-    assert_equal :new_assertion, handoff_assertions.delete(:new_assertion)
-    assert_true handoff_assertions.empty?
-  end
-  
-  test 'should add a teardown method for conducting handoff assertions' do
-    assert_true self.class.teardown_methods.include?(:conduct_and_clear_handoffs)
-  end
-  
   test 'should conduct each assertion in conduct_and_clear_handoffs' do
     handoff_assertions << assertion1 = mock(:conduct => nil)
     handoff_assertions << assertion2 = mock(:conduct => nil)
@@ -29,4 +12,27 @@ class HandoffTest < Test::Unit::TestCase
     assertion1.verify
     assertion2.verify
   end
+  
+  def blank_test_case
+    Class.new(Test::Unit::TestCase) do
+      define_method(:initialize) { super(:test_foo) }
+      define_method(:test_foo) {}
+    end
+  end
+  
+  test 'first call to assert_handoff in a test aliases and defines new teardown' do
+    test = blank_test_case.new
+    assert_equal [], test.singleton_methods
+    test.assert_handoff
+    assert_equal %w(teardown teardown_before_handoff_rewrite ), test.singleton_methods.sort
+  end
+  
+  test 'handoff-defined teardown does conduct_and_clear_handoffs then calls original teardown' do
+    test = blank_test_case.new
+    test.assert_handoff
+    test.expects(:conduct_and_clear_handoffs)
+    test.expects(:teardown_before_handoff_rewrite)
+    test.teardown
+  end
+  
 end

data/test/test_helper_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/test_helper'
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
 
 class TestHelperTest < Test::Unit::TestCase
   

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: handoff
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
-date: 2007-02-17 00:00:00 -05:00
+  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.
 require_paths: 
 - lib
@@ -12,7 +12,7 @@ email: ""
 homepage: http://handoff.rubyforge.org/
 rubyforge_project: 
 description: 
-autorequire: hand_off
+autorequire: handoff
 default_executable: 
 bindir: bin
 has_rdoc: true
@@ -34,6 +34,7 @@ files:
 - lib/handoff/argument_normalizer.rb
 - lib/handoff/assertion.rb
 - lib/handoff/usage_error.rb
+- lib/handoff/verifying_delegate.rb
 - README
 test_files: 
 - test/example_test.rb
@@ -41,6 +42,7 @@ test_files:
 - test/test_helper_test.rb
 - test/handoff/argument_normalizer_test.rb
 - test/handoff/assertion_test.rb
+- test/handoff/verifying_delegate_test.rb
 rdoc_options: []
 
 extra_rdoc_files: 
@@ -51,13 +53,5 @@ extensions: []
 
 requirements: []
 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: mocha
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
-    requirements: 
-    - - ">"
-      - !ruby/object:Gem::Version 
-        version: 0.0.0
-    version: 
+dependencies: []
+