bourne 1.0

data/test/acceptance/spy_test.rb

@@ -0,0 +1,134 @@
+require File.join(File.dirname(__FILE__), "acceptance_test_helper")
+require 'bourne'
+require 'matcher_helpers'
+
+module SpyTestMethods
+
+  def setup
+    setup_acceptance_test
+  end
+  
+  def teardown
+    teardown_acceptance_test
+  end
+  
+  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
+  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
+  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 }
+  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 }
+  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 }
+  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
+  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
+  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 }
+  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
+  end
+
+  def test_should_reject_not_enough_calls
+    instance = new_instance
+    instance.stubs(:to_s)
+    instance.to_s
+    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 }
+  end
+
+  def test_should_reject_too_many_calls
+    instance = new_instance
+    instance.stubs(:to_s)
+    2.times { instance.to_s }
+    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 }
+  end
+
+  def assert_fails(message=/not yet invoked/)
+    begin
+      yield
+    rescue Test::Unit::AssertionFailedError => exception
+      assert_match message, exception.message, "Test failed, but with the wrong message"
+      return
+    end
+    flunk("Expected to fail")
+  end
+
+end
+
+class PartialSpyTest < Test::Unit::TestCase
+  include AcceptanceTest
+  include SpyTestMethods
+
+  def new_instance
+    Object.new
+  end
+end
+
+class PureSpyTest < Test::Unit::TestCase
+  include AcceptanceTest
+  include SpyTestMethods
+
+  def new_instance
+    stub
+  end
+end

data/test/acceptance/stubba_example_test.rb

@@ -0,0 +1,102 @@
+require File.expand_path('../../test_helper', __FILE__)
+require 'mocha'
+
+class Widget
+  
+  def model
+    'original_model'
+  end
+    
+  class << self
+  
+    def find(options)
+      []
+    end
+  
+    def create(attributes)
+      Widget.new
+    end
+  
+  end
+  
+end
+
+module Thingy
+  
+  def self.wotsit
+    :hoojamaflip
+  end
+  
+end
+
+class StubbaExampleTest < Test::Unit::TestCase
+  
+  def test_should_stub_instance_method
+    widget = Widget.new
+    widget.expects(:model).returns('different_model')
+    assert_equal 'different_model', widget.model
+  end
+  
+  def test_should_stub_module_method
+    should_stub_module_method
+  end
+  
+  def test_should_stub_module_method_again
+    should_stub_module_method
+  end
+  
+  def test_should_stub_class_method
+    should_stub_class_method
+  end
+  
+  def test_should_stub_class_method_again
+    should_stub_class_method
+  end
+  
+  def test_should_stub_instance_method_on_any_instance_of_a_class
+    should_stub_instance_method_on_any_instance_of_a_class
+  end
+  
+  def test_should_stub_instance_method_on_any_instance_of_a_class_again
+    should_stub_instance_method_on_any_instance_of_a_class
+  end
+  
+  def test_should_stub_two_different_class_methods
+    should_stub_two_different_class_methods
+  end
+  
+  def test_should_stub_two_different_class_methods_again
+    should_stub_two_different_class_methods
+  end
+  
+  private
+  
+  def should_stub_module_method
+    Thingy.expects(:wotsit).returns(:dooda)
+    assert_equal :dooda, Thingy.wotsit
+  end
+  
+  def should_stub_class_method
+    widgets = [Widget.new]
+    Widget.expects(:find).with(:all).returns(widgets)
+    assert_equal widgets, Widget.find(:all)
+  end 
+  
+  def should_stub_two_different_class_methods
+    found_widgets = [Widget.new]
+    created_widget = Widget.new
+    Widget.expects(:find).with(:all).returns(found_widgets)
+    Widget.expects(:create).with(:model => 'wombat').returns(created_widget)
+    assert_equal found_widgets, Widget.find(:all)
+    assert_equal created_widget, Widget.create(:model => 'wombat')
+  end
+  
+  def should_stub_instance_method_on_any_instance_of_a_class
+    Widget.any_instance.expects(:model).at_least_once.returns('another_model')
+    widget_1 = Widget.new
+    widget_2 = Widget.new
+    assert_equal 'another_model', widget_1.model
+    assert_equal 'another_model', widget_2.model
+  end
+
+end

data/test/execution_point.rb

@@ -0,0 +1,36 @@
+class ExecutionPoint
+  
+  attr_reader :backtrace
+
+  def self.current
+    new(caller)
+  end
+  
+  def initialize(backtrace)
+    @backtrace = backtrace
+  end
+  
+  def file_name
+    return "unknown" unless @backtrace && @backtrace.first
+    /\A(.*?):\d+/.match(@backtrace.first)[1]
+  end
+  
+  def line_number
+    return "unknown" unless @backtrace && @backtrace.first
+    Integer(/\A.*?:(\d+)/.match(@backtrace.first)[1])
+  end
+
+  def ==(other)
+    return false unless other.is_a?(ExecutionPoint)
+    (file_name == other.file_name) and (line_number == other.line_number)
+  end
+  
+  def to_s
+    "file: #{file_name}; line: #{line_number}"
+  end
+  
+  def inspect
+    to_s
+  end
+  
+end

data/test/matcher_helpers.rb

@@ -0,0 +1,5 @@
+class Test::Unit::TestCase
+  def assert_matcher_accepts(matcher, instance)
+    assert matcher.matches?(instance), matcher.failure_message
+  end
+end

data/test/method_definer.rb

@@ -0,0 +1,24 @@
+require 'mocha/metaclass'
+
+module Mocha
+  
+  module ObjectMethods
+    def define_instance_method(method_symbol, &block)
+      __metaclass__.send(:define_method, method_symbol, block)
+    end
+
+    def replace_instance_method(method_symbol, &block)
+      raise "Cannot replace #{method_symbol} as #{self} does not respond to it." unless self.respond_to?(method_symbol)
+      define_instance_method(method_symbol, &block)
+    end
+
+    def define_instance_accessor(*symbols)
+      symbols.each { |symbol| __metaclass__.send(:attr_accessor, symbol) }
+    end
+  end
+  
+end
+
+class Object
+  include Mocha::ObjectMethods
+end

data/test/simple_counter.rb

@@ -0,0 +1,13 @@
+class SimpleCounter
+  
+  attr_reader :count
+  
+  def initialize
+    @count = 0
+  end
+  
+  def increment
+    @count += 1
+  end
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,19 @@
+unless defined?(STANDARD_OBJECT_PUBLIC_INSTANCE_METHODS)
+  STANDARD_OBJECT_PUBLIC_INSTANCE_METHODS = Object.public_instance_methods
+end
+
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__)))
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), 'unit'))
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), 'unit', 'parameter_matchers'))
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), 'acceptance'))
+
+if ENV['MOCHA_OPTIONS'] == 'use_test_unit_gem'
+  require 'rubygems'
+  gem 'test-unit'
+end
+
+require 'rubygems'
+require 'test/unit'
+gem 'mocha', '0.9.8'
+

data/test/test_runner.rb

@@ -0,0 +1,47 @@
+require 'test/unit/testcase'
+
+if defined?(MiniTest)
+  require 'mocha/integration/mini_test'
+  require File.expand_path('../mini_test_result', __FILE__)
+else
+  require 'test/unit/testresult'
+end
+
+module TestRunner
+  def run_as_test(test_result = nil, &block)
+    test_class = Class.new(Test::Unit::TestCase) do
+      define_method(:test_me, &block)
+    end
+    test = test_class.new(:test_me)
+    
+    if defined?(Test::Unit::TestResult)
+      test_result ||= Test::Unit::TestResult.new
+      test.run(test_result) {}
+      class << test_result
+        attr_reader :failures, :errors
+        def failure_messages
+          failures.map { |failure| failure.message }
+        end
+        def error_messages
+          errors.map { |error| error.message }
+        end
+      end
+    else
+      runner = MiniTest::Unit.new
+      test.run(runner)
+      test_result = MiniTestResult.new(runner, test)
+    end
+    
+    test_result
+  end
+  
+  def assert_passed(test_result)
+    flunk "Test failed unexpectedly with message: #{test_result.failures}" if test_result.failure_count > 0
+    flunk "Test failed unexpectedly with message: #{test_result.errors}" if test_result.error_count > 0
+  end
+
+  def assert_failed(test_result)
+    flunk "Test passed unexpectedly" if test_result.passed?
+  end
+
+end

data/test/unit/assert_received_test.rb

@@ -0,0 +1,145 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'test_runner'
+require 'bourne/api'
+require 'bourne/mockery'
+require 'mocha/object'
+
+class AssertReceivedTest < Test::Unit::TestCase
+
+  include Mocha
+  include TestRunner
+  include Mocha::API
+
+  def teardown
+    Mockery.reset_instance
+  end
+
+  class FakeMock
+    def initialize(name)
+      @name = name
+    end
+
+    def inspect
+      @name
+    end
+
+    def mocha
+      self
+    end
+  end
+
+  def test_passes_if_invocation_exists
+    method = :a_method
+    mock   = FakeMock.new('a mock')
+    Mockery.instance.invocation(mock, method, [])
+    assert_passes do
+      assert_received(mock, method)
+    end
+  end
+
+  def test_fails_if_invocation_doesnt_exist
+    method = :a_method
+    mock   = FakeMock.new('a mock')
+    assert_fails do
+      assert_received(mock, method)
+    end
+  end
+
+  def test_fails_if_invocation_exists_with_different_arguments
+    method = :a_method
+    mock   = FakeMock.new('a mock')
+    Mockery.instance.invocation(mock, method, [2, 1])
+    assert_fails do
+      assert_received(mock, method) {|expect| expect.with(1, 2) }
+    end
+  end
+
+  def test_passes_if_invocation_exists_with_wildcard_arguments
+    method = :a_method
+    mock   = FakeMock.new('a mock')
+    Mockery.instance.invocation(mock, method, ['hello'])
+    assert_passes do
+      assert_received(mock, method) {|expect| expect.with(is_a(String)) }
+    end
+  end
+
+  def test_passes_if_invocation_exists_with_exact_arguments
+    method = :a_method
+    mock   = FakeMock.new('a mock')
+    Mockery.instance.invocation(mock, method, ['hello'])
+    assert_passes do
+      assert_received(mock, method) {|expect| expect.with('hello') }
+    end
+  end
+
+  def test_fails_if_invocation_exists_only_on_other_mock
+    method = :a_method
+    mock   = FakeMock.new('a mock')
+    other  = 'another mock'
+    Mockery.instance.invocation(other, method, ['hello'])
+    assert_fails do
+      assert_received(mock, method)
+    end
+  end
+
+  def test_passes_if_invocation_exists_for_impersonating_mock
+    method = :a_method
+    object = Object.new
+    mock   = FakeMock.new('a mock')
+
+    class << object
+      attr_accessor :mocha
+    end
+    object.mocha = mock
+
+    Mockery.instance.invocation(mock, method, ['hello'])
+    assert_passes do
+      assert_received(object, method) {|expect| expect.with('hello') }
+    end
+  end
+
+  def test_passes_if_invocation_count_correct
+    method = :a_method
+    mock   = FakeMock.new('a mock')
+    2.times { Mockery.instance.invocation(mock, method, []) }
+    assert_passes do
+      assert_received(mock, method) {|expect| expect.twice }
+    end
+  end
+
+  def test_fails_if_invocation_count_too_low
+    method = :a_method
+    mock   = FakeMock.new('a mock')
+    Mockery.instance.invocation(mock, method, [])
+    assert_fails do
+      assert_received(mock, method) {|expect| expect.twice }
+    end
+  end
+
+  def test_fails_if_invocation_count_too_high
+    method = :a_method
+    mock   = FakeMock.new('a mock')
+    2.times { Mockery.instance.invocation(mock, method, []) }
+    assert_fails do
+      assert_received(mock, method) {|expect| expect.once }
+    end
+  end
+
+  def assert_passes(&block)
+    assert ! fails?(&block)
+  end
+
+  def assert_fails(&block)
+    assert fails?(&block)
+  end
+
+  def fails?
+    begin
+      yield
+      false
+    rescue Test::Unit::AssertionFailedError
+      true
+    end
+  end
+
+end