mocha 0.5.6 → 3.0.2

data/lib/mocha/object.rb

@@ -1,110 +0,0 @@
-require 'mocha/mock'
-require 'mocha/instance_method'
-require 'mocha/class_method'
-require 'mocha/any_instance_method'
-
-# Methods added all objects to allow mocking and stubbing on real objects.
-#
-# Methods return a Mocha::Expectation which can be further modified by methods on Mocha::Expectation.
-class Object
-  
-  def mocha # :nodoc:
-    @mocha ||= Mocha::Mock.new
-  end
-  
-  def reset_mocha # :nodoc:
-    @mocha = nil
-  end
-  
-  def stubba_method # :nodoc:
-    Mocha::InstanceMethod
-  end
-  
-  def stubba_object # :nodoc:
-    self
-  end
-  
-  # :call-seq: expects(symbol) -> expectation
-  #
-  # Adds an expectation that a method identified by +symbol+ must be called exactly once with any parameters.
-  # Returns the new expectation which can be further modified by methods on Mocha::Expectation.
-  #   product = Product.new
-  #   product.expects(:save).returns(true)
-  #   assert_equal false, product.save
-  #
-  # The original implementation of <tt>Product#save</tt> is replaced temporarily.
-  #
-  # The original implementation of <tt>Product#save</tt> is restored at the end of the test.
-  def expects(symbol) 
-    method = stubba_method.new(stubba_object, symbol)
-    $stubba.stub(method)
-    mocha.expects(symbol, caller)
-  end
-  
-  # :call-seq: stubs(symbol) -> expectation
-  #
-  # Adds an expectation that a method identified by +symbol+ may be called any number of times with any parameters.
-  # Returns the new expectation which can be further modified by methods on Mocha::Expectation.
-  #   product = Product.new
-  #   product.stubs(:save).returns(true)
-  #   assert_equal false, product.save
-  #
-  # The original implementation of <tt>Product#save</tt> is replaced temporarily.
-  #
-  # The original implementation of <tt>Product#save</tt> is restored at the end of the test.
-  def stubs(symbol) 
-    method = stubba_method.new(stubba_object, symbol)
-    $stubba.stub(method)
-    mocha.stubs(symbol, caller)
-  end
-  
-  def verify # :nodoc:
-    mocha.verify
-  end
-  
-end
-
-class Module # :nodoc:
-  
-  def stubba_method
-    Mocha::ClassMethod
-  end
-    
-end
-  
-class Class
-  
-  def stubba_method # :nodoc:
-    Mocha::ClassMethod
-  end
-
-  class AnyInstance # :nodoc:
-    
-    def initialize(klass)
-      @stubba_object = klass
-    end
-    
-    def stubba_method
-      Mocha::AnyInstanceMethod
-    end
-    
-    def stubba_object
-      @stubba_object
-    end
-    
-  end
-  
-  # :call-seq: any_instance -> mock object
-  #
-  # Returns a mock object which will detect calls to any instance of this class.
-  #   Product.any_instance.stubs(:save).returns(false)
-  #   product_1 = Product.new
-  #   assert_equal false, product_1.save
-  #   product_2 = Product.new
-  #   assert_equal false, product_2.save
-  def any_instance
-    @any_instance ||= AnyInstance.new(self)
-  end
-  
-end
-

data/lib/mocha/parameter_matchers/base.rb

@@ -1,15 +0,0 @@
-module Mocha
-  
-  module ParameterMatchers
-    
-    class Base # :nodoc:
-      
-      def to_matcher
-        self
-      end
-      
-    end
-    
-  end
-  
-end

data/lib/mocha/parameter_matchers/object.rb

@@ -1,9 +0,0 @@
-require 'mocha/parameter_matchers/equals'
-
-class Object
-  
-  def to_matcher
-    Mocha::ParameterMatchers::Equals.new(self)
-  end
-  
-end

data/lib/mocha/pretty_parameters.rb

@@ -1,28 +0,0 @@
-require 'mocha/inspect'
-
-module Mocha
-
-  class PrettyParameters
-  
-    def initialize(params)
-      @params = params
-      @params_string = params.mocha_inspect
-    end
-  
-    def pretty
-      remove_outer_array_braces!
-      remove_outer_hash_braces!
-      @params_string
-    end
-  
-    def remove_outer_array_braces!
-      @params_string = @params_string.gsub(/^\[|\]$/, '')
-    end
-  
-    def remove_outer_hash_braces!
-      @params_string = @params_string.gsub(/^\{|\}$/, '') if @params.length == 1
-    end
-  
-  end
-  
-end

data/lib/mocha/setup_and_teardown.rb

@@ -1,23 +0,0 @@
-require 'mocha/central'
-
-module Mocha
-  
-  module SetupAndTeardown
-  
-    def setup_stubs
-      $stubba = Mocha::Central.new
-    end
-    
-    def verify_stubs
-      $stubba.verify_all { yield if block_given? } if $stubba
-    end
-  
-    def teardown_stubs
-      if $stubba then
-        $stubba.unstub_all
-        $stubba = nil
-      end
-    end
-
-  end
-end

data/lib/mocha/single_yield.rb

@@ -1,18 +0,0 @@
-module Mocha # :nodoc:
-  
-  class SingleYield # :nodoc:
-    
-    attr_reader :parameters
-    
-    def initialize(*parameters)
-      @parameters = parameters
-    end
-    
-    def each
-      yield(@parameters)
-    end
-    
-  end
-  
-end
-    

data/lib/mocha/standalone.rb

@@ -1,32 +0,0 @@
-require 'mocha/auto_verify'
-require 'mocha/parameter_matchers'
-require 'mocha/setup_and_teardown'
-
-module Mocha
-  
-  module Standalone
-    
-    include AutoVerify
-    include ParameterMatchers
-    include SetupAndTeardown
-    
-    def mocha_setup
-      setup_stubs
-    end
-    
-    def mocha_verify(&block)
-      verify_mocks(&block)
-      verify_stubs(&block)
-    end
-    
-    def mocha_teardown
-      begin
-        teardown_mocks
-      ensure
-        teardown_stubs
-      end
-    end
-    
-  end
-  
-end

data/lib/mocha/stub.rb

@@ -1,18 +0,0 @@
-require 'mocha/expectation'
-
-module Mocha # :nodoc:
-
-  class Stub < Expectation # :nodoc:
-
-    def initialize(mock, method_name, backtrace = nil)
-      super
-      @expected_count = Range.at_least(0)
-    end
-    
-    def verify
-      true
-    end
-
-  end
-
-end

data/lib/mocha/test_case_adapter.rb

@@ -1,49 +0,0 @@
-require 'mocha/expectation_error'
-
-module Mocha
-  
-  module TestCaseAdapter
-
-    def self.included(base)
-      base.class_eval do
-
-        alias_method :run_before_mocha_test_case_adapter, :run
-
-        def run(result)
-          yield(Test::Unit::TestCase::STARTED, name)
-          @_result = result
-          begin
-            mocha_setup
-            begin
-              setup
-              __send__(@method_name)
-              mocha_verify { add_assertion }
-            rescue Mocha::ExpectationError => e
-              add_failure(e.message, e.backtrace)
-            rescue Test::Unit::AssertionFailedError => e
-              add_failure(e.message, e.backtrace)
-            rescue StandardError, ScriptError
-              add_error($!)
-            ensure
-              begin
-                teardown
-              rescue Test::Unit::AssertionFailedError => e
-                add_failure(e.message, e.backtrace)
-              rescue StandardError, ScriptError
-                add_error($!)
-              end
-            end
-          ensure
-            mocha_teardown
-          end
-          result.add_run
-          yield(Test::Unit::TestCase::FINISHED, name)
-        end
-                
-      end
-      
-    end
-    
-  end
-  
-end

data/lib/mocha_standalone.rb

@@ -1,2 +0,0 @@
-require 'mocha/standalone'
-require 'mocha/object'

data/lib/stubba.rb

@@ -1,2 +0,0 @@
-# for backwards compatibility
-require 'mocha'

data/test/acceptance/expected_invocation_count_acceptance_test.rb

@@ -1,187 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-require 'mocha'
-require 'test_runner'
-
-class ExpectedInvocationCountAcceptanceTest < Test::Unit::TestCase
-
-  include TestRunner
-
-  def test_should_pass_if_method_is_never_expected_and_is_never_called
-    test_result = run_test do
-      mock = mock('mock')
-      mock.expects(:method).never
-      0.times { mock.method }
-    end
-    assert_passed(test_result)
-  end
-  
-  def test_should_fail_if_method_is_never_expected_but_is_called_once
-    test_result = run_test do
-      mock = mock('mock')
-      mock.expects(:method).never
-      1.times { mock.method }
-    end
-    assert_failed(test_result)
-    failure_messages = test_result.failures.map { |failure| failure.message }
-    assert_equal ['#<Mock:mock>.method(any_parameters) - expected calls: 0, actual calls: 1'], failure_messages
-  end
-  
-  def test_should_pass_if_method_is_expected_twice_and_is_called_twice
-    test_result = run_test do
-      mock = mock('mock')
-      mock.expects(:method).times(2)
-      2.times { mock.method }
-    end
-    assert_passed(test_result)
-  end
-  
-  def test_should_fail_if_method_is_expected_twice_but_is_called_once
-    test_result = run_test do
-      mock = mock('mock')
-      mock.expects(:method).times(2)
-      1.times { mock.method }
-    end
-    assert_failed(test_result)
-    failure_messages = test_result.failures.map { |failure| failure.message }
-    assert_equal ['#<Mock:mock>.method(any_parameters) - expected calls: 2, actual calls: 1'], failure_messages
-  end
-  
-  def test_should_fail_if_method_is_expected_twice_but_is_called_three_times
-    test_result = run_test do
-      mock = mock('mock')
-      mock.expects(:method).times(2)
-      3.times { mock.method }
-    end
-    assert_failed(test_result)
-    failure_messages = test_result.failures.map { |failure| failure.message }
-    assert_equal ['#<Mock:mock>.method(any_parameters) - expected calls: 2, actual calls: 3'], failure_messages
-  end
-  
-  def test_should_pass_if_method_is_expected_between_two_and_four_times_and_is_called_twice
-    test_result = run_test do
-      mock = mock('mock')
-      mock.expects(:method).times(2..4)
-      2.times { mock.method }
-    end
-    assert_passed(test_result)
-  end
-
-  def test_should_pass_if_method_is_expected_between_two_and_four_times_and_is_called_three_times
-    test_result = run_test do
-      mock = mock('mock')
-      mock.expects(:method).times(2..4)
-      3.times { mock.method }
-    end
-    assert_passed(test_result)
-  end
-
-  def test_should_pass_if_method_is_expected_between_two_and_four_times_and_is_called_four_times
-    test_result = run_test do
-      mock = mock('mock')
-      mock.expects(:method).times(2..4)
-      4.times { mock.method }
-    end
-    assert_passed(test_result)
-  end
-
-  def test_should_fail_if_method_is_expected_between_two_and_four_times_and_is_called_once
-    test_result = run_test do
-      mock = mock('mock')
-      mock.expects(:method).times(2..4)
-      1.times { mock.method }
-    end
-    assert_failed(test_result)
-    failure_messages = test_result.failures.map { |failure| failure.message }
-    assert_equal ['#<Mock:mock>.method(any_parameters) - expected calls: 2..4, actual calls: 1'], failure_messages
-  end
-
-  def test_should_fail_if_method_is_expected_between_two_and_four_times_and_is_called_five_times
-    test_result = run_test do
-      mock = mock('mock')
-      mock.expects(:method).times(2..4)
-      5.times { mock.method }
-    end
-    assert_failed(test_result)
-    failure_messages = test_result.failures.map { |failure| failure.message }
-    assert_equal ['#<Mock:mock>.method(any_parameters) - expected calls: 2..4, actual calls: 5'], failure_messages
-  end
-  
-  def test_should_pass_if_method_is_expected_at_least_once_and_is_called_once
-    test_result = run_test do
-      mock = mock('mock')
-      mock.expects(:method).at_least_once
-      1.times { mock.method }
-    end
-    assert_passed(test_result)
-  end
-  
-  def test_should_pass_if_method_is_expected_at_least_once_and_is_called_twice
-    test_result = run_test do
-      mock = mock('mock')
-      mock.expects(:method).at_least_once
-      2.times { mock.method }
-    end
-    assert_passed(test_result)
-  end
-  
-  def test_should_fail_if_method_is_expected_at_least_once_but_is_never_called
-    test_result = run_test do
-      mock = mock('mock')
-      mock.expects(:method).at_least_once
-      0.times { mock.method }
-    end
-    assert_failed(test_result)
-    failure_messages = test_result.failures.map { |failure| failure.message }
-    assert_equal ['#<Mock:mock>.method(any_parameters) - expected calls: at least 1, actual calls: 0'], failure_messages
-  end
-  
-  def test_should_pass_if_method_is_expected_at_most_once_and_is_never_called
-    test_result = run_test do
-      mock = mock('mock')
-      mock.expects(:method).at_most_once
-      0.times { mock.method }
-    end
-    assert_passed(test_result)
-  end
-  
-  def test_should_pass_if_method_is_expected_at_most_once_and_called_once
-    test_result = run_test do
-      mock = mock('mock')
-      mock.expects(:method).at_most_once
-      1.times { mock.method }
-    end
-    assert_passed(test_result)
-  end
-  
-  def test_should_fail_if_method_is_expected_at_most_once_but_is_called_twice
-    test_result = run_test do
-      mock = mock('mock')
-      mock.expects(:method).at_most_once
-      2.times { mock.method }
-    end
-    assert_failed(test_result)
-    failure_messages = test_result.failures.map { |failure| failure.message }
-    assert_equal ['#<Mock:mock>.method(any_parameters) - expected calls: at most 1, actual calls: 2'], failure_messages
-  end
-  
-  def test_should_pass_if_method_is_never_expected_and_is_never_called_even_if_everything_is_stubbed
-    test_result = run_test do
-      stub = stub_everything('stub')
-      stub.expects(:method).never
-      0.times { stub.method }
-    end
-    assert_passed(test_result)
-  end
-  
-  def test_should_fail_if_method_is_never_expected_but_is_called_once_even_if_everything_is_stubbed
-    test_result = run_test do
-      stub = stub_everything('stub')
-      stub.expects(:method).never
-      1.times { stub.method }
-    end
-    assert_failed(test_result)
-    failure_messages = test_result.failures.map { |failure| failure.message }
-    assert_equal ['#<Mock:stub>.method(any_parameters) - expected calls: 0, actual calls: 1'], failure_messages
-  end
-  
-end

data/test/acceptance/mocha_acceptance_test.rb

@@ -1,98 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-require 'mocha'
-
-class MochaAcceptanceTest < Test::Unit::TestCase
-  
-  class Rover
-
-    def initialize(left_track, right_track, steps_per_metre, steps_per_degree)
-      @left_track, @right_track, @steps_per_metre, @steps_per_degree = left_track, right_track, steps_per_metre, steps_per_degree
-    end
-
-    def forward(metres)
-      @left_track.step(metres * @steps_per_metre)
-      @right_track.step(metres * @steps_per_metre)
-      wait
-    end
-
-    def backward(metres)
-      forward(-metres)
-    end
-    
-    def left(degrees)
-      @left_track.step(-degrees * @steps_per_degree)
-      @right_track.step(+degrees * @steps_per_degree)
-      wait
-    end
-    
-    def right(degrees)
-      left(-degrees)
-    end
-    
-    def wait
-      while (@left_track.moving? or @right_track.moving?); end
-    end
-
-  end
-  
-  def test_should_step_both_tracks_forward_ten_steps
-    left_track = mock('left_track')
-    right_track = mock('right_track')
-    steps_per_metre = 5
-    rover = Rover.new(left_track, right_track, steps_per_metre, nil)
-    
-    left_track.expects(:step).with(10)
-    right_track.expects(:step).with(10)
-    
-    left_track.stubs(:moving?).returns(false)
-    right_track.stubs(:moving?).returns(false)
-    
-    rover.forward(2)
-  end
-  
-  def test_should_step_both_tracks_backward_ten_steps
-    left_track = mock('left_track')
-    right_track = mock('right_track')
-    steps_per_metre = 5
-    rover = Rover.new(left_track, right_track, steps_per_metre, nil)
-    
-    left_track.expects(:step).with(-10)
-    right_track.expects(:step).with(-10)
-    
-    left_track.stubs(:moving?).returns(false)
-    right_track.stubs(:moving?).returns(false)
-    
-    rover.backward(2)
-  end
-  
-  def test_should_step_left_track_forwards_five_steps_and_right_track_backwards_five_steps
-    left_track = mock('left_track')
-    right_track = mock('right_track')
-    steps_per_degree = 5.0 / 90.0
-    rover = Rover.new(left_track, right_track, nil, steps_per_degree)
-    
-    left_track.expects(:step).with(+5)
-    right_track.expects(:step).with(-5)
-    
-    left_track.stubs(:moving?).returns(false)
-    right_track.stubs(:moving?).returns(false)
-    
-    rover.right(90)
-  end
-  
-  def test_should_step_left_track_backwards_five_steps_and_right_track_forwards_five_steps
-    left_track = mock('left_track')
-    right_track = mock('right_track')
-    steps_per_degree = 5.0 / 90.0
-    rover = Rover.new(left_track, right_track, nil, steps_per_degree)
-    
-    left_track.expects(:step).with(-5)
-    right_track.expects(:step).with(+5)
-    
-    left_track.stubs(:moving?).returns(false)
-    right_track.stubs(:moving?).returns(false)
-    
-    rover.left(90)
-  end
-  
-end

data/test/acceptance/mock_with_initializer_block_acceptance_test.rb

@@ -1,44 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-require 'mocha'
-require 'test_runner'
-
-class MockWithInitializerBlockAcceptanceTest < Test::Unit::TestCase
-  
-  include TestRunner
-
-  def test_should_expect_two_method_invocations_and_receive_both_of_them
-    test_result = run_test do
-      mock = mock() do
-        expects(:method_1)
-        expects(:method_2)
-      end
-      mock.method_1
-      mock.method_2
-    end
-    assert_passed(test_result)
-  end
-
-  def test_should_expect_two_method_invocations_but_receive_only_one_of_them
-    test_result = run_test do
-      mock = mock() do
-        expects(:method_1)
-        expects(:method_2)
-      end
-      mock.method_1
-    end
-    assert_failed(test_result)
-  end
-
-  def test_should_stub_methods
-    test_result = run_test do
-      mock = mock() do
-        stubs(:method_1).returns(1)
-        stubs(:method_2).returns(2)
-      end
-      assert_equal 1, mock.method_1
-      assert_equal 2, mock.method_2
-    end
-    assert_passed(test_result)
-  end
-
-end