bourne 1.0 → 1.1.0

data/.gitignore

@@ -0,0 +1,7 @@
+pkg
+*.swp
+.swo
+*~
+tags
+rdoc
+*.gem

data/.travis.yml

@@ -0,0 +1,4 @@
+rvm:
+  - 1.9.3
+  - 1.9.2
+  - 1.8.7

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,20 @@
+PATH
+  remote: .
+  specs:
+    bourne (1.1.0)
+      mocha (= 0.10.4)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    metaclass (0.0.1)
+    mocha (0.10.4)
+      metaclass (~> 0.0.1)
+    rake (0.9.2.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bourne!
+  rake

data/README.md

@@ -0,0 +1,76 @@
+Bourne
+======
+
+Bourne extends mocha to allow detailed tracking and querying of stub and mock
+invocations. It allows test spies using the have_received rspec matcher and
+assert_received for Test::Unit. Bourne was extracted from jferris-mocha, a fork
+of mocha that adds test spies.
+
+Test Spies
+----------
+
+Test spies are a form of test double that preserves the normal four-phase unit
+test order and allows separation of stubbing and verification.
+
+Using a test spy is like using a mocked expectation except that there are two steps:
+
+1. Stub out a method for which you want to verify invocations
+2. Use an assertion or matcher to verify that the stub was invoked correctly
+
+Examples
+--------
+
+RSpec:
+
+    mock.should have_received(:to_s)
+    Radio.should have_received(:new).with(1041)
+    radio.should have_received(:volume).with(11).twice
+    radio.should have_received(:off).never
+
+You also want to configure RSpec to use mocha for mocking:
+
+    RSpec.configure do |config|
+      config.mock_with :mocha
+    end
+
+Test::Unit:
+
+    assert_received(mock, :to_s)
+    assert_received(Radio, :new) {|expect| expect.with(1041) }
+    assert_received(radio, :volume) {|expect| expect.with(11).twice }
+    assert_received(radio, :off) {|expect| expect.never }
+
+See Mocha::API for more information.
+
+Install
+-------
+
+    gem install bourne
+
+More Information
+----------------
+
+* [RDoc](http://rdoc.info/projects/thoughtbot/bourne)
+* [Issues](http://github.com/thoughtbot/bourne/issues)
+* [Mocha mailing list](http://groups.google.com/group/mocha-developer)
+
+Credits
+-------
+
+Bourne was written by Joe Ferris. Mocha was written by James Mead. Several of
+the test examples and helpers used in the Bourne test suite were copied
+directly from Mocha.
+
+Thanks to thoughtbot for inspiration, ideas, and funding. Thanks to James for
+writing mocha.
+
+![thoughtbot](http://thoughtbot.com/images/tm/logo.png)
+
+Thank you to all [the contributors](https://github.com/thoughtbot/bourne/contributors)!
+
+The names and logos for thoughtbot are trademarks of thoughtbot, inc.
+
+License
+-------
+
+Bourne is Copyright © 2010-2011 Joe Ferris and thoughtbot. It is free software, and may be redistributed under the terms specified in the LICENSE file.

data/Rakefile

@@ -1,12 +1,12 @@
-require 'rake/rdoctask'
-require 'rake/gempackagetask'
+require 'bundler/setup'
+require 'bundler/gem_tasks'
 require 'rake/testtask'
 
 desc "Run all tests"
 task 'default' => ['test:units', 'test:acceptance', 'test:performance']
 
 namespace 'test' do
-  unit_tests = FileList['test/unit/**/*_test.rb']
+  unit_tests       = FileList['test/unit/**/*_test.rb']
   acceptance_tests = FileList['test/acceptance/*_test.rb']
 
   desc "Run unit tests"
@@ -35,27 +35,20 @@ end
 
 def benchmark_test_case(klass, iterations)
   require 'benchmark'
-  require 'test/unit/ui/console/testrunner'
-  begin
-    require 'test/unit/ui/console/outputlevel'
-    silent_option = { :output_level => Test::Unit::UI::Console::OutputLevel::SILENT }
-  rescue LoadError
-    silent_option = Test::Unit::UI::SILENT
-  end
-  time = Benchmark.realtime { iterations.times { Test::Unit::UI::Console::TestRunner.run(klass, silent_option) } }
-end
-
-eval("$specification = #{IO.read('bourne.gemspec')}")
-Rake::GemPackageTask.new($specification) do |package|
-  package.need_zip = true
-  package.need_tar = true
-end
 
-desc 'Generate documentation.'
-Rake::RDocTask.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'Bourne'
-  rdoc.options << '--line-numbers' << "--main" << "README"
-  rdoc.rdoc_files.include('README')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+  if defined?(MiniTest)
+    MiniTest::Unit.output = StringIO.new
+    Benchmark.realtime { iterations.times { |i| MiniTest::Unit.new.run([klass]) } }
+  else
+    load 'test/unit/ui/console/testrunner.rb' unless defined?(Test::Unit::UI::Console::TestRunner)
+    unless $silent_option
+      begin
+        load 'test/unit/ui/console/outputlevel.rb' unless defined?(Test::Unit::UI::Console::OutputLevel::SILENT)
+        $silent_option = { :output_level => Test::Unit::UI::Console::OutputLevel::SILENT }
+      rescue LoadError
+        $silent_option = Test::Unit::UI::SILENT
+      end
+    end
+    Benchmark.realtime { iterations.times { Test::Unit::UI::Console::TestRunner.run(klass, $silent_option) } }
+  end
 end

data/bourne.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "bourne/version"
+
+Gem::Specification.new do |s|
+  s.name        = 'bourne'
+  s.version     = Bourne::VERSION.dup
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Joe Ferris"]
+  s.email       = 'jferris@thoughtbot.com'
+  s.homepage    = 'http://github.com/thoughtbot/bourne'
+  s.summary     = 'Adds test spies to mocha.'
+  s.description = %q{Extends mocha to allow detailed tracking and querying of
+    stub and mock invocations. Allows test spies using the have_received rspec
+    matcher and assert_received for Test::Unit. Extracted from the
+    jferris-mocha fork.}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency('mocha', '= 0.10.4')
+
+  s.add_development_dependency('rake')
+end

data/lib/bourne/api.rb

@@ -16,6 +16,9 @@ module Mocha # :nodoc:
       assert matcher.matches?(mock), matcher.failure_message
     end
 
+    class InvalidHaveReceived < StandardError
+    end
+
     class HaveReceived #:nodoc:
       def initialize(expected_method_name)
         @expected_method_name = expected_method_name
@@ -41,7 +44,12 @@ module Mocha # :nodoc:
         @expectation.invocation_count = invocation_count
         @expectation.verified?
       end
-      
+
+      def does_not_match?(mock)
+        raise InvalidHaveReceived.new("should_not have_received(:#{@expected_method_name}) is invalid, please use" +
+                                        " should have_received(:#{@expected_method_name}).never")
+      end
+
       def failure_message
         @expectation.mocha_inspect
       end

data/lib/bourne/mock.rb

@@ -13,9 +13,18 @@ module Mocha # :nodoc:
         matching_expectation_allowing_invocation.invoke(arguments, &block)
       else
         if (matching_expectation = @expectations.match(symbol, *arguments)) || (!matching_expectation && !@everything_stubbed)
+          matching_expectation.invoke(arguments, &block) if matching_expectation
           message = UnexpectedInvocation.new(self, symbol, *arguments).to_s
-          message << Mockery.instance.mocha_inspect
+          message << @mockery.mocha_inspect
           raise ExpectationError.new(message, caller)
+        else
+          target = if self.respond_to? :mocha
+            self.mocha
+          else
+            mocha
+          end
+          Mockery.instance.invocation(target, symbol, arguments)
+          nil
         end
       end
     end

data/lib/bourne/version.rb

@@ -0,0 +1,3 @@
+module Bourne
+  VERSION = '1.1.0'.freeze
+end

data/test/acceptance/spy_test.rb

@@ -14,99 +14,109 @@ module SpyTestMethods
   
   def test_should_accept_wildcard_stub_call_without_arguments
     instance = new_instance
-    instance.stubs(:to_s)
-    instance.to_s
-    assert_received(instance, :to_s)
-    assert_matcher_accepts have_received(:to_s), instance
+    instance.stubs(:magic)
+    instance.magic
+    assert_received(instance, :magic)
+    assert_matcher_accepts have_received(:magic), instance
   end
 
   def test_should_accept_wildcard_stub_call_with_arguments
     instance = new_instance
-    instance.stubs(:to_s)
-    instance.to_s(:argument)
-    assert_received(instance, :to_s)
-    assert_matcher_accepts have_received(:to_s), instance
+    instance.stubs(:magic)
+    instance.magic(:argument)
+    assert_received(instance, :magic)
+    assert_matcher_accepts have_received(:magic), instance
   end
 
   def test_should_not_accept_wildcard_stub_without_call
     instance = new_instance
-    instance.stubs(:to_s)
-    assert_fails { assert_received(instance, :to_s) }
-    assert_fails { assert_matcher_accepts have_received(:to_s), instance }
+    instance.stubs(:magic)
+    assert_fails { assert_received(instance, :magic) }
+    assert_fails { assert_matcher_accepts have_received(:magic), instance }
   end
 
   def test_should_not_accept_call_without_arguments
     instance = new_instance
-    instance.stubs(:to_s)
-    instance.to_s
-    assert_fails { assert_received(instance, :to_s) {|expect| expect.with(1) } }
-    assert_fails { assert_matcher_accepts have_received(:to_s).with(1), instance }
+    instance.stubs(:magic)
+    instance.magic
+    assert_fails { assert_received(instance, :magic) {|expect| expect.with(1) } }
+    assert_fails { assert_matcher_accepts have_received(:magic).with(1), instance }
   end
 
   def test_should_not_accept_call_with_different_arguments
     instance = new_instance
-    instance.stubs(:to_s)
-    instance.to_s(2)
-    assert_fails { assert_received(instance, :to_s) {|expect| expect.with(1) } }
-    assert_fails { assert_matcher_accepts have_received(:to_s).with(1), instance }
+    instance.stubs(:magic)
+    instance.magic(2)
+    assert_fails { assert_received(instance, :magic) {|expect| expect.with(1) } }
+    assert_fails { assert_matcher_accepts have_received(:magic).with(1), instance }
   end
 
   def test_should_accept_call_with_correct_arguments
     instance = new_instance
-    instance.stubs(:to_s)
-    instance.to_s(1)
-    assert_received(instance, :to_s) {|expect| expect.with(1) }
-    assert_matcher_accepts have_received(:to_s).with(1), instance
+    instance.stubs(:magic)
+    instance.magic(1)
+    assert_received(instance, :magic) {|expect| expect.with(1) }
+    assert_matcher_accepts have_received(:magic).with(1), instance
   end
 
   def test_should_accept_call_with_wildcard_arguments
     instance = new_instance
-    instance.stubs(:to_s)
-    instance.to_s('hello')
-    assert_received(instance, :to_s) {|expect| expect.with(is_a(String)) }
-    assert_matcher_accepts have_received(:to_s).with(is_a(String)), instance
+    instance.stubs(:magic)
+    instance.magic('hello')
+    assert_received(instance, :magic) {|expect| expect.with(is_a(String)) }
+    assert_matcher_accepts have_received(:magic).with(is_a(String)), instance
   end
 
   def test_should_reject_call_on_different_mock
     instance = new_instance
     other    = new_instance
-    instance.stubs(:to_s)
-    other.stubs(:to_s)
-    other.to_s('hello')
-    assert_fails { assert_received(instance, :to_s) {|expect| expect.with(is_a(String)) } }
-    assert_fails { assert_matcher_accepts have_received(:to_s).with(is_a(String)), instance }
+    instance.stubs(:magic)
+    other.stubs(:magic)
+    other.magic('hello')
+    assert_fails { assert_received(instance, :magic) {|expect| expect.with(is_a(String)) } }
+    assert_fails { assert_matcher_accepts have_received(:magic).with(is_a(String)), instance }
   end
 
   def test_should_accept_correct_number_of_calls
     instance = new_instance
-    instance.stubs(:to_s)
-    2.times { instance.to_s }
-    assert_received(instance, :to_s) {|expect| expect.twice }
-    assert_matcher_accepts have_received(:to_s).twice, instance
+    instance.stubs(:magic)
+    2.times { instance.magic }
+    assert_received(instance, :magic) {|expect| expect.twice }
+    assert_matcher_accepts have_received(:magic).twice, instance
+  end
+
+  def test_should_not_allow_should_not
+    begin
+      have_received(:magic).does_not_match?(new_instance)
+    rescue Mocha::API::InvalidHaveReceived => exception
+      assert_match "should_not have_received(:magic) is invalid, please use should have_received(:magic).never", exception.message, "Test failed, but with the wrong message"
+      return
+    end
+    flunk("Expected to fail")
   end
 
   def test_should_reject_not_enough_calls
     instance = new_instance
-    instance.stubs(:to_s)
-    instance.to_s
+    instance.stubs(:magic)
+    instance.magic
     message = /expected exactly twice/
-    assert_fails(message) { assert_received(instance, :to_s) {|expect| expect.twice } }
-    assert_fails(message) { assert_matcher_accepts have_received(:to_s).twice, instance }
+    assert_fails(message) { assert_received(instance, :magic) {|expect| expect.twice } }
+    assert_fails(message) { assert_matcher_accepts have_received(:magic).twice, instance }
   end
 
   def test_should_reject_too_many_calls
     instance = new_instance
-    instance.stubs(:to_s)
-    2.times { instance.to_s }
+    instance.stubs(:magic)
+    2.times { instance.magic }
     message = /expected exactly once/
-    assert_fails(message) { assert_received(instance, :to_s) {|expect| expect.once } }
-    assert_fails(message) { assert_matcher_accepts have_received(:to_s).once, instance }
+    assert_fails(message) { assert_received(instance, :magic) {|expect| expect.once } }
+    assert_fails(message) { assert_matcher_accepts have_received(:magic).once, instance }
   end
 
   def assert_fails(message=/not yet invoked/)
     begin
       yield
-    rescue Test::Unit::AssertionFailedError => exception
+    rescue FailedAssertion => exception
       assert_match message, exception.message, "Test failed, but with the wrong message"
       return
     end
@@ -132,3 +142,19 @@ class PureSpyTest < Test::Unit::TestCase
     stub
   end
 end
+
+class StubEverythingSpyTest < Test::Unit::TestCase
+  include AcceptanceTest
+  def setup
+    setup_acceptance_test
+  end
+  
+  def teardown
+    teardown_acceptance_test
+  end  
+  def test_should_match_invocations_with_no_explicit_stubbing
+    instance = stub_everything
+    instance.surprise!
+    assert_received(instance, :surprise!)
+  end
+end

data/test/method_definer.rb

@@ -1,4 +1,4 @@
-require 'mocha/metaclass'
+require 'metaclass'
 
 module Mocha
   
@@ -21,4 +21,4 @@ end
 
 class Object
   include Mocha::ObjectMethods
-end
+end

data/test/mini_test_result.rb

@@ -0,0 +1,83 @@
+require 'stringio'
+require 'test/unit/testcase'
+require 'minitest/unit'
+
+class MiniTestResult
+  
+  FAILURE_PATTERN = %r{(Failure)\:\n([^\(]+)\(([^\)]+)\) \[([^\]]+)\]\:\n(.*)\n}m
+  ERROR_PATTERN   = %r{(Error)\:\n([^\(]+)\(([^\)]+)\)\:\n(.+?)\n}m
+  
+  def self.parse_failure(raw)
+    matches = FAILURE_PATTERN.match(raw)
+    return nil unless matches
+    Failure.new(matches[2], matches[3], [matches[4]], matches[5])
+  end
+  
+  def self.parse_error(raw)
+    matches = ERROR_PATTERN.match(raw)
+    return nil unless matches
+    backtrace = raw.gsub(ERROR_PATTERN, '').split("\n").map(&:strip)
+    Error.new(matches[2], matches[3], matches[4], backtrace)
+  end
+  
+  class Failure
+    attr_reader :method, :test_case, :location, :message
+    def initialize(method, test_case, location, message)
+      @method, @test_case, @location, @message = method, test_case, location, message
+    end
+  end
+  
+  class Error
+    class Exception
+      attr_reader :message, :backtrace
+      def initialize(message, location)
+        @message, @backtrace = message, location
+      end
+    end
+    
+    attr_reader :method, :test_case, :exception
+    def initialize(method, test_case, message, backtrace)
+      @method, @test_case, @exception = method, test_case, Exception.new(message, backtrace)
+    end
+  end
+  
+  def initialize(runner, test)
+    @runner, @test = runner, test
+  end
+  
+  def failure_count
+    @runner.failures
+  end
+  
+  def assertion_count
+    @test._assertions
+  end
+  
+  def error_count
+    @runner.errors
+  end
+  
+  def passed?
+    @test.passed?
+  end
+  
+  def failures
+    @runner.report.map { |puked| MiniTestResult.parse_failure(puked) }.compact
+  end
+  
+  def errors
+    @runner.report.map { |puked| MiniTestResult.parse_error(puked) }.compact
+  end
+  
+  def failure_messages
+    failures.map(&:message)
+  end
+  
+  def failure_message_lines
+    failure_messages.map { |message| message.split("\n") }.flatten
+  end
+  
+  def error_messages
+    errors.map { |e| e.exception.message }
+  end
+end

data/test/test_helper.rb

@@ -13,7 +13,11 @@ if ENV['MOCHA_OPTIONS'] == 'use_test_unit_gem'
   gem 'test-unit'
 end
 
-require 'rubygems'
 require 'test/unit'
-gem 'mocha', '0.9.8'
+require 'mocha'
 
+if defined?(MiniTest)
+  FailedAssertion = MiniTest::Assertion
+else
+  FailedAssertion = Test::Unit::AssertionFailedError
+end

data/test/test_runner.rb

@@ -22,6 +22,9 @@ module TestRunner
         def failure_messages
           failures.map { |failure| failure.message }
         end
+        def failure_message_lines
+          failure_messages.map { |message| message.split("\n") }.flatten
+        end
         def error_messages
           errors.map { |error| error.message }
         end
@@ -44,4 +47,5 @@ module TestRunner
     flunk "Test passed unexpectedly" if test_result.passed?
   end
 
-end
+end
+

data/test/unit/assert_received_test.rb

@@ -137,7 +137,7 @@ class AssertReceivedTest < Test::Unit::TestCase
     begin
       yield
       false
-    rescue Test::Unit::AssertionFailedError
+    rescue FailedAssertion
       true
     end
   end

data/test/unit/expectation_test.rb

@@ -20,6 +20,9 @@ class ExpectationTest < Test::Unit::TestCase
     def invocation(mock, method_name, args)
       @invocations << { :mock => mock, :method_name => method_name, :args => args }
     end
+
+    def verify(assertion_counter = nil)
+    end
   end
 
   def setup
@@ -317,7 +320,8 @@ class ExpectationTest < Test::Unit::TestCase
     expectation = new_expectation.times(2)
     1.times {expectation.invoke([])}
     assert !expectation.verified?
-    assert_match(/expected exactly twice, already invoked once/i, expectation.mocha_inspect)
+    assert_match(/expected exactly twice/i, expectation.mocha_inspect)
+    assert_match(/invoked once/i, expectation.mocha_inspect)
   end
   
   def test_should_not_verify_successfully_if_expected_call_was_made_too_many_times

data/test/unit/have_received_test.rb

@@ -131,7 +131,7 @@ module HaveReceivedTestMethods
     begin
       yield
       false
-    rescue Test::Unit::AssertionFailedError
+    rescue FailedAssertion
       true
     end
   end

data/test/unit/mock_test.rb

@@ -9,7 +9,7 @@ class MockTest < Test::Unit::TestCase
   include Mocha
   
   def test_should_set_single_expectation
-   mock = Mock.new
+   mock = build_mock
    mock.expects(:method1).returns(1)
    assert_nothing_raised(ExpectationError) do
      assert_equal 1, mock.method1
@@ -17,30 +17,30 @@ class MockTest < Test::Unit::TestCase
   end 
 
   def test_should_build_and_store_expectations
-   mock = Mock.new
+   mock = build_mock
    expectation = mock.expects(:method1)
    assert_not_nil expectation
    assert_equal [expectation], mock.expectations.to_a
   end
   
   def test_should_not_stub_everything_by_default
-    mock = Mock.new
+    mock = build_mock
     assert_equal false, mock.everything_stubbed
   end
-  
+
   def test_should_stub_everything
-    mock = Mock.new
+    mock = build_mock
     mock.stub_everything
     assert_equal true, mock.everything_stubbed
   end
   
   def test_should_be_able_to_extend_mock_object_with_module
-    mock = Mock.new
+    mock = build_mock
     assert_nothing_raised(ExpectationError) { mock.extend(Module.new) }
   end
   
   def test_should_be_equal
-    mock = Mock.new
+    mock = build_mock
     assert_equal true, mock.eql?(mock)
   end
   
@@ -51,55 +51,55 @@ class MockTest < Test::Unit::TestCase
   end
   
   def test_should_be_able_to_mock_standard_object_methods
-    mock = Mock.new
+    mock = build_mock
     OBJECT_METHODS.each { |method| mock.__expects__(method.to_sym).returns(method) }
     OBJECT_METHODS.each { |method| assert_equal method, mock.__send__(method.to_sym) }
     assert mock.__verified__?
   end
   
   def test_should_be_able_to_stub_standard_object_methods
-    mock = Mock.new
+    mock = build_mock
     OBJECT_METHODS.each { |method| mock.__stubs__(method.to_sym).returns(method) }
     OBJECT_METHODS.each { |method| assert_equal method, mock.__send__(method.to_sym) }
   end
   
   def test_should_create_and_add_expectations
-    mock = Mock.new
+    mock = build_mock
     expectation1 = mock.expects(:method1)
     expectation2 = mock.expects(:method2)
     assert_equal [expectation1, expectation2].to_set, mock.expectations.to_set
   end
   
   def test_should_pass_backtrace_into_expectation
-    mock = Mock.new
+    mock = build_mock
     backtrace = Object.new
     expectation = mock.expects(:method1, backtrace)
     assert_equal backtrace, expectation.backtrace
   end
   
   def test_should_pass_backtrace_into_stub
-    mock = Mock.new
+    mock = build_mock
     backtrace = Object.new
     stub = mock.stubs(:method1, backtrace)
     assert_equal backtrace, stub.backtrace
   end
   
   def test_should_create_and_add_stubs
-    mock = Mock.new
+    mock = build_mock
     stub1 = mock.stubs(:method1)
     stub2 = mock.stubs(:method2)
     assert_equal [stub1, stub2].to_set, mock.expectations.to_set
   end
   
   def test_should_invoke_expectation_and_return_result
-    mock = Mock.new
+    mock = build_mock
     mock.expects(:my_method).returns(:result)
     result = mock.my_method
     assert_equal :result, result
   end
   
   def test_should_not_raise_error_if_stubbing_everything
-    mock = Mock.new
+    mock = build_mock
     mock.stub_everything
     result = nil
     assert_nothing_raised(ExpectationError) do
@@ -109,7 +109,7 @@ class MockTest < Test::Unit::TestCase
   end
   
   def test_should_raise_assertion_error_for_unexpected_method_call
-    mock = Mock.new
+    mock = build_mock
     error = assert_raise(ExpectationError) do
       mock.unexpected_method_called(:my_method, :argument1, :argument2)
     end
@@ -120,7 +120,7 @@ class MockTest < Test::Unit::TestCase
   end
   
   def test_should_not_verify_successfully_because_not_all_expectations_have_been_satisfied
-    mock = Mock.new
+    mock = build_mock
     mock.expects(:method1)
     mock.expects(:method2)
     mock.method1
@@ -128,7 +128,7 @@ class MockTest < Test::Unit::TestCase
   end
   
   def test_should_increment_assertion_counter_for_every_verified_expectation
-    mock = Mock.new
+    mock = build_mock
     
     mock.expects(:method1)
     mock.method1
@@ -144,7 +144,7 @@ class MockTest < Test::Unit::TestCase
   end
   
   def test_should_yield_supplied_parameters_to_block
-    mock = Mock.new
+    mock = build_mock
     parameters_for_yield = [1, 2, 3]
     mock.expects(:method1).yields(*parameters_for_yield)
     yielded_parameters = nil
@@ -153,69 +153,69 @@ class MockTest < Test::Unit::TestCase
   end
   
   def test_should_set_up_multiple_expectations_with_return_values
-    mock = Mock.new
+    mock = build_mock
     mock.expects(:method1 => :result1, :method2 => :result2)
     assert_equal :result1, mock.method1
     assert_equal :result2, mock.method2
   end
   
   def test_should_set_up_multiple_stubs_with_return_values
-    mock = Mock.new
+    mock = build_mock
     mock.stubs(:method1 => :result1, :method2 => :result2)
     assert_equal :result1, mock.method1
     assert_equal :result2, mock.method2
   end
   
   def test_should_keep_returning_specified_value_for_stubs
-    mock = Mock.new
+    mock = build_mock
     mock.stubs(:method1).returns(1)
     assert_equal 1, mock.method1
     assert_equal 1, mock.method1
   end
   
   def test_should_keep_returning_specified_value_for_expects
-    mock = Mock.new
+    mock = build_mock
     mock.expects(:method1).times(2).returns(1)
     assert_equal 1, mock.method1
     assert_equal 1, mock.method1
   end
   
   def test_should_match_most_recent_call_to_expects
-    mock = Mock.new
+    mock = build_mock
     mock.expects(:method1).returns(0)
     mock.expects(:method1).returns(1)
     assert_equal 1, mock.method1
   end
 
   def test_should_match_most_recent_call_to_stubs
-    mock = Mock.new
+    mock = build_mock
     mock.stubs(:method1).returns(0)
     mock.stubs(:method1).returns(1)
     assert_equal 1, mock.method1
   end
 
   def test_should_match_most_recent_call_to_stubs_or_expects
-    mock = Mock.new
+    mock = build_mock
     mock.stubs(:method1).returns(0)
     mock.expects(:method1).returns(1)
     assert_equal 1, mock.method1
   end
 
   def test_should_match_most_recent_call_to_expects_or_stubs
-    mock = Mock.new
+    mock = build_mock
     mock.expects(:method1).returns(0)
     mock.stubs(:method1).returns(1)
     assert_equal 1, mock.method1
   end
   
   def test_should_respond_to_expected_method
-    mock = Mock.new
+    mock = build_mock
     mock.expects(:method1)
     assert_equal true, mock.respond_to?(:method1)
   end
   
   def test_should_not_respond_to_unexpected_method
-    mock = Mock.new
+    mock = build_mock
     assert_equal false, mock.respond_to?(:method1)
   end
   
@@ -223,7 +223,7 @@ class MockTest < Test::Unit::TestCase
     instance = Class.new do
       define_method(:respond_to?) { |symbol| true }
     end.new
-    mock = Mock.new
+    mock = build_mock
     mock.responds_like(instance)
     assert_equal true, mock.respond_to?(:invoked_method)
   end
@@ -232,21 +232,18 @@ class MockTest < Test::Unit::TestCase
     instance = Class.new do
       define_method(:respond_to?) { |symbol| false }
     end.new
-    mock = Mock.new
+    mock = build_mock
     mock.responds_like(instance)
     assert_equal false, mock.respond_to?(:invoked_method)
   end
   
   def test_should_return_itself_to_allow_method_chaining
-    mock = Mock.new
+    mock = build_mock
     assert_same mock.responds_like(Object.new), mock
   end
   
   def test_should_not_raise_no_method_error_if_mock_is_not_restricted_to_respond_like_a_responder
-    instance = Class.new do
-      define_method(:respond_to?) { true }
-    end.new
-    mock = Mock.new
+    mock = build_mock
     mock.stubs(:invoked_method)
     assert_nothing_raised(NoMethodError) { mock.invoked_method }
   end
@@ -255,7 +252,7 @@ class MockTest < Test::Unit::TestCase
     instance = Class.new do
       define_method(:respond_to?) { |symbol| true }
     end.new
-    mock = Mock.new
+    mock = build_mock
     mock.responds_like(instance)
     mock.stubs(:invoked_method)
     assert_nothing_raised(NoMethodError) { mock.invoked_method }
@@ -266,7 +263,7 @@ class MockTest < Test::Unit::TestCase
       define_method(:respond_to?) { |symbol| false }
       define_method(:mocha_inspect) { 'mocha_inspect' }
     end.new
-    mock = Mock.new
+    mock = build_mock
     mock.responds_like(instance)
     mock.stubs(:invoked_method)
     assert_raises(NoMethodError) { mock.invoked_method }
@@ -277,7 +274,7 @@ class MockTest < Test::Unit::TestCase
       define_method(:respond_to?) { |symbol| false }
       define_method(:mocha_inspect) { 'mocha_inspect' }
     end.new
-    mock = Mock.new
+    mock = build_mock
     mock.responds_like(instance)
     mock.stubs(:invoked_method)
     begin
@@ -288,17 +285,25 @@ class MockTest < Test::Unit::TestCase
   end
   
   def test_should_handle_respond_to_with_private_methods_param_without_error
-    mock = Mock.new
+    mock = build_mock
     assert_nothing_raised{ mock.respond_to?(:object_id, false) }
   end
   
   def test_should_respond_to_any_method_if_stubbing_everything
-    mock = Mock.new
+    mock = build_mock
     mock.stub_everything
     assert mock.respond_to?(:abc)
     assert mock.respond_to?(:xyz)
   end
 
+  def test_should_remove_expectation_for_unstubbed_method
+    mock = build_mock
+    mock.expects(:method1)
+    mock.unstub(:method1)
+    e = assert_raises(ExpectationError) { mock.method1 }
+    assert_match(/unexpected invocation/, e.message)
+  end
+
   class FakeExpectation
     attr_reader :args
 
@@ -322,8 +327,12 @@ class MockTest < Test::Unit::TestCase
     expectation = FakeExpectation.new
     mock.expectations.add expectation
     mock.send(method, *args)
-
     assert_equal args, expectation.args
   end
-  
+
+  private
+
+  def build_mock
+    Mock.new(nil)
+  end
 end

data/test/unit/mockery_test.rb

@@ -73,6 +73,7 @@ class MockeryTest < Test::Unit::TestCase
   class FakeMethod
     def stub; end
     def unstub; end
+    def matches?(other); true; end
   end
   
   def test_should_unstub_all_methods_on_teardown

metadata

@@ -1,72 +1,61 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: bourne
-version: !ruby/object:Gem::Version 
-  hash: 15
-  prerelease: false
-  segments: 
-  - 1
-  - 0
-  version: "1.0"
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Joe Ferris
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2010-06-08 00:00:00 -04:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-02-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: mocha
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &70334145515340 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - "="
-      - !ruby/object:Gem::Version 
-        hash: 43
-        segments: 
-        - 0
-        - 9
-        - 8
-        version: 0.9.8
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 0.10.4
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: rake
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *70334145515340
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70334145514700 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id002
-description: |-
-  Extends mocha to allow detailed tracking and querying of
-      stub and mock invocations. Allows test spies using the have_received rspec
-      matcher and assert_received for Test::Unit. Extracted from the
-      jferris-mocha fork.
+  prerelease: false
+  version_requirements: *70334145514700
+description: ! "Extends mocha to allow detailed tracking and querying of\n    stub
+  and mock invocations. Allows test spies using the have_received rspec\n    matcher
+  and assert_received for Test::Unit. Extracted from the\n    jferris-mocha fork."
 email: jferris@thoughtbot.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
-- README
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- Gemfile.lock
 - LICENSE
-files: 
+- README.md
+- Rakefile
+- bourne.gemspec
+- lib/bourne.rb
 - lib/bourne/api.rb
 - lib/bourne/expectation.rb
 - lib/bourne/invocation.rb
 - lib/bourne/mock.rb
 - lib/bourne/mockery.rb
-- lib/bourne.rb
+- lib/bourne/version.rb
 - test/acceptance/acceptance_test_helper.rb
 - test/acceptance/mocha_example_test.rb
 - test/acceptance/spy_test.rb
@@ -74,6 +63,7 @@ files:
 - test/execution_point.rb
 - test/matcher_helpers.rb
 - test/method_definer.rb
+- test/mini_test_result.rb
 - test/simple_counter.rb
 - test/test_helper.rb
 - test/test_runner.rb
@@ -83,46 +73,45 @@ files:
 - test/unit/invocation_test.rb
 - test/unit/mock_test.rb
 - test/unit/mockery_test.rb
-- LICENSE
-- Rakefile
-- README
-has_rdoc: true
 homepage: http://github.com/thoughtbot/bourne
 licenses: []
-
 post_install_message: 
-rdoc_options: 
-- --title
-- Bourne
-- --main
-- README
-- --line-numbers
-require_paths: 
+rdoc_options: []
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7.pre.1
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Adds test spies to mocha.
-test_files: []
-
+test_files:
+- test/acceptance/acceptance_test_helper.rb
+- test/acceptance/mocha_example_test.rb
+- test/acceptance/spy_test.rb
+- test/acceptance/stubba_example_test.rb
+- test/execution_point.rb
+- test/matcher_helpers.rb
+- test/method_definer.rb
+- test/mini_test_result.rb
+- test/simple_counter.rb
+- test/test_helper.rb
+- test/test_runner.rb
+- test/unit/assert_received_test.rb
+- test/unit/expectation_test.rb
+- test/unit/have_received_test.rb
+- test/unit/invocation_test.rb
+- test/unit/mock_test.rb
+- test/unit/mockery_test.rb

data/README

@@ -1,59 +0,0 @@
-= Bourne
-
-Bourne extends mocha to allow detailed tracking and querying of stub and mock
-invocations. It allows test spies using the have_received rspec matcher and
-assert_received for Test::Unit. Bourne was extracted from jferris-mocha, a fork
-of mocha that adds test spies.
-
-== Test Spies
-
-Test spies are a form of test double that preserves the normal four-phase unit
-test order and allows separation of stubbing and verification.
-
-Using a test spy is like using a mocked expectation except that there are two steps:
-
-1. Stub out a method for which you want to verify invocations
-2. Use an assertion or matcher to verify that the stub was invoked correctly
-
-== Examples
-
-  # rspec
-
-  mock.should have_received(:to_s)
-  Radio.should have_received(:new).with(1041)
-  radio.should have_received(:volume).with(11).twice
-  radio.should have_received(:off).never
-
-  # Test::Unit
-
-  assert_received(mock, :to_s)
-  assert_received(Radio, :new) {|expect| expect.with(1041) }
-  assert_received(radio, :volume) {|expect| expect.with(11).twice }
-  assert_received(radio, :off) {|expect| expect.never }
-
-See Mocha::API for more information.
-
-== Download
-
-Rubygems:
-  gem install bourne
-
-Github: http://github.com/thoughtbot/bourne/tree/master
-
-== More Information
-
-* RDoc[http://rdoc.info/projects/thoughtbot/bourne]
-* Mocha mailing list[http://groups.google.com/group/mocha-developer?hl=en]
-* Issues[http://github.com/thoughtbot/bourne/issues]
-* GIANT ROBOTS SMASHING INTO OTHER GIANT ROBOTS[http://giantrobots.thoughtbot.com]
-
-== Author
-
-Bourne was written by Joe Ferris. Mocha was written by James Mead. Several of
-the test examples and helpers used in the Bourne test suite were copied
-directly from Mocha.
-
-Thanks to thoughtbot for inspiration, ideas, and funding. Thanks to James for
-writing mocha.
-
-Copyright 2010 Joe Ferris and thoughtbot[http://www.thoughtbot.com], inc.