mocha 0.10.5 → 1.13.0

data/lib/mocha/object.rb

@@ -1,223 +0,0 @@
-require 'mocha/mockery'
-require 'mocha/instance_method'
-require 'mocha/class_method'
-require 'mocha/module_method'
-require 'mocha/any_instance_method'
-require 'mocha/argument_iterator'
-
-module Mocha
-  
-  # Methods added to 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.
-  module ObjectMethods
-  
-    def mocha # :nodoc:
-      @mocha ||= Mocha::Mockery.instance.mock_impersonating(self)
-    end
-  
-    def reset_mocha # :nodoc:
-      @mocha = nil
-    end
-  
-    def stubba_method # :nodoc:
-      Mocha::InstanceMethod
-    end
-  
-    def stubba_object # :nodoc:
-      self
-    end
-  
-    # :call-seq: expects(method_name) -> expectation
-    #            expects(method_names_vs_return_values) -> last expectation
-    #
-    # Adds an expectation that a method identified by +method_name+ 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 true, 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.
-    #
-    # If +method_names_vs_return_values+ is a +Hash+, an expectation will be set up for each entry using the key as +method_name+ and value as +return_value+.
-    #   product = Product.new
-    #   product.expects(:valid? => true, :save => true)
-    #
-    #   # exactly equivalent to
-    #
-    #   product = Product.new
-    #   product.expects(:valid?).returns(true)
-    #   product.expects(:save).returns(true)
-    def expects(method_name_or_hash)
-      if method_name_or_hash.to_s =~ /the[^a-z]*spanish[^a-z]*inquisition/i
-        raise Mocha::ExpectationError.new('NOBODY EXPECTS THE SPANISH INQUISITION!')
-      end
-      expectation = nil
-      mockery = Mocha::Mockery.instance
-      iterator = ArgumentIterator.new(method_name_or_hash)
-      iterator.each { |*args|
-        method_name = args.shift
-        mockery.on_stubbing(self, method_name)
-        method = stubba_method.new(stubba_object, method_name)
-        mockery.stubba.stub(method)
-        expectation = mocha.expects(method_name, caller)
-        expectation.returns(args.shift) if args.length > 0
-      }
-      expectation
-    end
-  
-    # :call-seq: stubs(method_name) -> expectation
-    #            stubs(method_names_vs_return_values) -> last expectation
-    #
-    # Adds an expectation that a method identified by +method_name+ 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 true, 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.
-    #
-    # If +method_names_vs_return_values+ is a +Hash+, an expectation will be set up for each entry using the key as +method_name+ and value as +return_value+.
-    #   product = Product.new
-    #   product.stubs(:valid? => true, :save => true)
-    #
-    #   # exactly equivalent to
-    #
-    #   product = Product.new
-    #   product.stubs(:valid?).returns(true)
-    #   product.stubs(:save).returns(true)
-    def stubs(method_name_or_hash)
-      expectation = nil
-      mockery = Mocha::Mockery.instance
-      iterator = ArgumentIterator.new(method_name_or_hash)
-      iterator.each { |*args|
-        method_name = args.shift
-        mockery.on_stubbing(self, method_name)
-        method = stubba_method.new(stubba_object, method_name)
-        mockery.stubba.stub(method)
-        expectation = mocha.stubs(method_name, caller)
-        expectation.returns(args.shift) if args.length > 0
-      }
-      expectation
-    end
-    
-    # :call-seq: unstub(*method_names)
-    #
-    # Removes the method stub added by calls to #expects or #stubs.
-    # Restores the original behaviour of the method before it was stubbed.
-    #   multiplier = Multiplier.new
-    #   multiplier.double(2) # => 4
-    #   multiplier.stubs(:double).raises
-    #   multiplier.double(2) # => raises exception
-    #   multiplier.unstub(:double)
-    #   multiplier.double(2) # => 4
-    #
-    # The original implementation of <tt>Multiplier#double</tt> is replaced temporarily.
-    #
-    # The original implementation of <tt>Multiplier#double</tt> is restored when #unstub is called.
-    #
-    # WARNING: If you #unstub a method which still has unsatisfied expectations, you may be removing
-    # the only way those expectations can be satisfied. Use #unstub with care.
-    #
-    # If multiple +method_names+ are supplied, each method is unstubbed.
-    #   multiplier.unstub(:double, :triple)
-    #
-    #   # exactly equivalent to
-    #
-    #   multiplier.unstub(:double)
-    #   multiplier.unstub(:triple)
-    def unstub(*method_names)
-      mockery = Mocha::Mockery.instance
-      method_names.each do |method_name|
-        method = stubba_method.new(stubba_object, method_name)
-        mockery.stubba.unstub(method)
-      end
-    end
-  
-    def method_exists?(method, include_public_methods = true) # :nodoc:
-      if include_public_methods
-        return true if public_methods(include_superclass_methods = true).include?(method)
-        return true if respond_to?(method.to_sym)
-      end
-      return true if protected_methods(include_superclass_methods = true).include?(method)
-      return true if private_methods(include_superclass_methods = true).include?(method)
-      return false
-    end
-  
-  end
-  
-  module ModuleMethods # :nodoc:
-    
-    def stubba_method
-      Mocha::ModuleMethod
-    end
-    
-  end
-  
-  # Methods added all classes to allow mocking and stubbing on real objects.
-  module ClassMethods
-    
-    def stubba_method # :nodoc:
-      Mocha::ClassMethod
-    end
-
-    class AnyInstance # :nodoc:
-    
-      def initialize(klass)
-        @stubba_object = klass
-      end
-    
-      def mocha
-        @mocha ||= Mocha::Mockery.instance.mock_impersonating_any_instance_of(@stubba_object)
-      end
-
-      def stubba_method
-        Mocha::AnyInstanceMethod
-      end
-    
-      def stubba_object
-        @stubba_object
-      end
-    
-      def method_exists?(method, include_public_methods = true)
-        if include_public_methods
-          return true if @stubba_object.public_instance_methods(include_superclass_methods = true).include?(method)
-        end
-        return true if @stubba_object.protected_instance_methods(include_superclass_methods = true).include?(method)
-        return true if @stubba_object.private_instance_methods(include_superclass_methods = true).include?(method)
-        return false
-      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
-  
-end
-
-class Object # :nodoc:
-  include Mocha::ObjectMethods
-end
-
-class Module # :nodoc:
-  include Mocha::ModuleMethods
-end
-
-class Class # :nodoc:
-  include Mocha::ClassMethods
-end

data/lib/mocha/options.rb

@@ -1 +0,0 @@
-$mocha_options = (ENV['MOCHA_OPTIONS'] || '').split(',').inject({}) { |hash, key| hash[key] = true; hash }

data/lib/mocha/parameter_matchers/object.rb

@@ -1,15 +0,0 @@
-require 'mocha/parameter_matchers/equals'
-
-module Mocha
-  
-  module ObjectMethods
-    def to_matcher # :nodoc:
-      Mocha::ParameterMatchers::Equals.new(self)
-    end
-  end
-  
-end
-
-class Object
-  include Mocha::ObjectMethods
-end

data/lib/mocha/parameter_matchers/query_string.rb

@@ -1,47 +0,0 @@
-require 'mocha/parameter_matchers/base'
-require 'uri'
-
-module Mocha
-  module ParameterMatchers
-
-    # :call-seq: has_equivalent_query_string(uri) -> parameter_matcher
-    #
-    # Matches a URI without regard to the ordering of parameters in the query string
-    #   object = mock()
-    #   object.expects(:method_1).with(has_equivalent_query_string('http://example.com/foo?a=1&b=2))
-    #   object.method_1('http://example.com/foo?b=2&a=1')
-    #   # no error raised
-    #
-    #   object = mock()
-    #   object.expects(:method_1).with(has_equivalent_query_string('http://example.com/foo?a=1&b=2))
-    #   object.method_1('http://example.com/foo?a=1&b=3')
-    #   # error raised, because the query parameters were different
-    def has_equivalent_query_string(uri)
-      QueryStringMatches.new(uri)
-    end
-
-    class QueryStringMatches < Base # :nodoc:
-
-      def initialize(uri)
-        @uri = URI.parse(uri)
-      end
-
-      def matches?(available_parameters)
-        actual = explode(URI.parse(available_parameters.shift))
-        expected = explode(@uri)
-        actual == expected
-      end
-
-      def mocha_inspect
-        "has_equivalent_query_string(#{@uri.mocha_inspect})"
-      end
-
-    private
-      def explode(uri)
-        query_hash = (uri.query || '').split('&').inject({}){ |h, kv| h.merge(Hash[*kv.split('=')]) }
-        URI::Generic::COMPONENT.inject({}){ |h, k| h.merge(k => uri.__send__(k)) }.merge(:query => query_hash)
-      end
-
-    end
-  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/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 +0,0 @@
-require 'mocha/api'

data/lib/mocha/unexpected_invocation.rb

@@ -1,18 +0,0 @@
-module Mocha # :nodoc:
-
-  class UnexpectedInvocation
-    
-    def initialize(mock, symbol, *arguments)
-      @mock = mock
-      @method_matcher = MethodMatcher.new(symbol)
-      @parameters_matcher = ParametersMatcher.new(arguments)
-    end
-    
-    def to_s
-      method_signature = "#{@mock.mocha_inspect}.#{@method_matcher.mocha_inspect}#{@parameters_matcher.mocha_inspect}"
-      "unexpected invocation: #{method_signature}\n"
-    end
-    
-  end
-  
-end

data/lib/mocha_standalone.rb

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

data/lib/stubba.rb

@@ -1,4 +0,0 @@
-# for backwards compatibility
-require 'mocha'
-require 'mocha/deprecation'
-Mocha::Deprecation.warning "require 'stubba' is no longer needed and stubba.rb will soon be removed"

data/test/acceptance/acceptance_test_helper.rb

@@ -1,41 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'test_runner'
-require 'mocha/configuration'
-require 'introspection'
-
-module AcceptanceTest
-  
-  class FakeLogger
-  
-    attr_reader :warnings
-    
-    def initialize
-      @warnings = []
-    end
-    
-    def warn(message)
-      @warnings << message
-    end
-  
-  end
-  
-  attr_reader :logger
-
-  include TestRunner
-  
-  def setup_acceptance_test
-    Mocha::Configuration.reset_configuration
-    @logger = FakeLogger.new
-    mockery = Mocha::Mockery.instance
-    @original_logger = mockery.logger
-    mockery.logger = @logger
-  end
-  
-  def teardown_acceptance_test
-    Mocha::Configuration.reset_configuration
-    Mocha::Mockery.instance.logger = @original_logger
-  end
-  
-  include Introspection::Assertions
-  
-end

data/test/acceptance/api_test.rb

@@ -1,139 +0,0 @@
-require File.expand_path('../acceptance_test_helper', __FILE__)
-require 'mocha_standalone'
-require 'simple_counter'
-
-class NotATestUnitAssertionFailedError < StandardError
-end
-
-class NotATestUnitTestCase
-  
-  include Mocha::API
-  
-  attr_reader :assertion_counter
-  
-  def initialize
-    @assertion_counter = SimpleCounter.new
-  end
-  
-  def run(test_method)
-    mocha_setup
-    begin
-      prepare
-      begin
-        send(test_method)
-        mocha_verify(@assertion_counter)
-      rescue Mocha::ExpectationError => e
-        new_error = NotATestUnitAssertionFailedError.new(e.message)
-        new_error.set_backtrace(e.backtrace)
-        raise new_error
-      ensure
-        cleanup
-      end
-    ensure
-      mocha_teardown
-    end
-  end
-  
-  def prepare
-  end
-  
-  def cleanup
-  end
-    
-end
-
-class SampleTest < NotATestUnitTestCase
-  
-  def mocha_with_fulfilled_expectation
-    mockee = mock()
-    mockee.expects(:blah)
-    mockee.blah
-  end
-  
-  def mocha_with_unfulfilled_expectation
-    mockee = mock()
-    mockee.expects(:blah)
-  end
-  
-  def mocha_with_unexpected_invocation
-    mockee = mock()
-    mockee.blah
-  end
-  
-  def stubba_with_fulfilled_expectation
-    stubbee = Class.new { define_method(:blah) {} }.new
-    stubbee.expects(:blah)
-    stubbee.blah
-  end
-  
-  def stubba_with_unfulfilled_expectation
-    stubbee = Class.new { define_method(:blah) {} }.new
-    stubbee.expects(:blah)
-  end
-  
-  def mocha_with_matching_parameter
-    mockee = mock()
-    mockee.expects(:blah).with(has_key(:wibble))
-    mockee.blah(:wibble => 1)
-  end
-  
-  def mocha_with_non_matching_parameter
-    mockee = mock()
-    mockee.expects(:blah).with(has_key(:wibble))
-    mockee.blah(:wobble => 2)
-  end
-  
-end
-
-require 'test/unit'
-
-class APITest < Test::Unit::TestCase
-  
-  attr_reader :sample_test
-
-  include AcceptanceTest
-  
-  def setup
-    @sample_test = SampleTest.new
-    setup_acceptance_test
-  end
-  
-  def teardown
-    teardown_acceptance_test
-  end
-  
-  def test_should_pass_mocha_test
-    assert_nothing_raised { sample_test.run(:mocha_with_fulfilled_expectation) }
-    assert_equal 1, sample_test.assertion_counter.count
-  end
-
-  def test_should_fail_mocha_test_due_to_unfulfilled_exception
-    assert_raises(NotATestUnitAssertionFailedError) { sample_test.run(:mocha_with_unfulfilled_expectation) }
-    assert_equal 1, sample_test.assertion_counter.count
-  end
-
-  def test_should_fail_mocha_test_due_to_unexpected_invocation
-    assert_raises(NotATestUnitAssertionFailedError) { sample_test.run(:mocha_with_unexpected_invocation) }
-    assert_equal 0, sample_test.assertion_counter.count
-  end
-
-  def test_should_pass_stubba_test
-    assert_nothing_raised { sample_test.run(:stubba_with_fulfilled_expectation) }
-    assert_equal 1, sample_test.assertion_counter.count
-  end
-
-  def test_should_fail_stubba_test
-    assert_raises(NotATestUnitAssertionFailedError) { sample_test.run(:stubba_with_unfulfilled_expectation) }
-    assert_equal 1, sample_test.assertion_counter.count
-  end
-
-  def test_should_pass_mocha_test_with_matching_parameter
-    assert_nothing_raised { sample_test.run(:mocha_with_matching_parameter) }
-    assert_equal 1, sample_test.assertion_counter.count
-  end
-
-  def test_should_fail_mocha_test_with_non_matching_parameter
-    assert_raises(NotATestUnitAssertionFailedError) { sample_test.run(:mocha_with_non_matching_parameter) }
-  end
-
-end

data/test/acceptance/bug_18914_test.rb

@@ -1,43 +0,0 @@
-require File.expand_path('../acceptance_test_helper', __FILE__)
-require 'mocha'
-
-class Bug18914Test < Test::Unit::TestCase
-  
-  include AcceptanceTest
-  
-  def setup
-    setup_acceptance_test
-  end
-  
-  def teardown
-    teardown_acceptance_test
-  end
-  
-  class AlwaysEql
-    
-    def my_method
-      true
-    end
-    
-    def ==(o)
-      true
-    end
-    
-    def eql?(o)
-      true
-    end
-    
-  end
-
-  def test_should_not_allow_stubbing_of_non_mock_instance_disrupted_by_legitimate_overriding_of_eql_method
-    
-    always_eql_1 = AlwaysEql.new
-    always_eql_1.stubs(:my_method).returns(false)
-    
-    always_eql_2 = AlwaysEql.new
-    always_eql_2.stubs(:my_method).returns(false)
-    
-    assert_equal false, always_eql_2.my_method
-  end
-  
-end

data/test/acceptance/bug_21465_test.rb

@@ -1,34 +0,0 @@
-require File.expand_path('../acceptance_test_helper', __FILE__)
-require 'mocha'
-
-class Bug21465Test < Test::Unit::TestCase
-  
-  include AcceptanceTest
-  
-  def setup
-    setup_acceptance_test
-  end
-  
-  def teardown
-    teardown_acceptance_test
-  end
-  
-  def test_should_allow_expected_method_name_to_be_a_string
-    test_result = run_as_test do
-      mock = mock()
-      mock.expects('wibble')
-      mock.wibble
-    end
-    assert_passed(test_result)
-  end
-  
-  def test_should_allow_stubbed_method_name_to_be_a_string
-    test_result = run_as_test do
-      mock = mock()
-      mock.stubs('wibble')
-      mock.wibble
-    end
-    assert_passed(test_result)
-  end
-  
-end

data/test/acceptance/bug_21563_test.rb

@@ -1,25 +0,0 @@
-require File.expand_path('../acceptance_test_helper', __FILE__)
-require 'mocha'
-
-class Bug21563Test < Test::Unit::TestCase
-  
-  include AcceptanceTest
-  
-  def setup
-    setup_acceptance_test
-  end
-  
-  def teardown
-    teardown_acceptance_test
-  end
-  
-  def test_should_allow_stubbing_of_verified_method
-    test_result = run_as_test do
-      object = Object.new
-      object.stubs(:verified?).returns(false)
-      assert !object.verified?
-    end
-    assert_passed(test_result)
-  end
-  
-end