mockr 0.1

data/lib/mockr.rb

@@ -0,0 +1,222 @@
+require 'test/unit'
+
+module Mockr
+
+  ################################################################################
+
+  class Mock
+    include ::Test::Unit
+
+    attr_reader :proxy
+
+    # Create a new Mock, with an optional initialisation block.  If provided,
+    # the block will be called with the new instance.
+    #
+    # Example:
+    #  Mock.new do |m|
+    #    m.stubs.some_method
+    #  end
+    def initialize &block
+      @expectations = []
+      @satisfied_expectations = []
+      create_proxy
+      block.call(self) if block
+    end
+
+    # Tell the mock to respond to a call, optionally with specific parameters.
+    #
+    # The call can be called an arbitrary number of times by the client code
+    # without affecting the result of #verify.
+    #
+    # Parameters to the expected call will be used to match the actual parameters
+    # passed by client code later.  The match (===) method of the expectation
+    # parameter is used to determine whether the client's call matched this
+    # anticipated call.
+    #
+    # Examples:
+    #  mock.stubs.bang!
+    #  mock.stubs.ping.as { :pong }
+    #  mock.stubs.hello?(/World/).as { true }  # Respond with +true+ if called with a parameter for which <tt>/World/ === param</tt> is true
+    def stubs
+      CallRecorder.new(method(:stub_call))
+    end
+
+    # Tell the mock to expect a call, optionally with specific parameters.
+    # If the call has not been made when #verify is called, #verify will fail
+    # with a Test::Unit::AssertionFailed.
+    #
+    # Parameters to the expected call will be used to match the actual parameters
+    # passed by client code later.  The match (===) method of the expectation
+    # parameter is used to determine whether the client's call matched this anticipated
+    # call.
+    #
+    # Examples:
+    #  mock.expects.bang!
+    #  mock.expects.ping.as { :pong }
+    #  mock.expects.safe?(1..10).as { true }  # Expect a call with a parameter for which <tt>(1..10) === param</tt>
+    def expects
+      CallRecorder.new(method(:expect_call))
+    end
+
+    # Check that the expected calls to this mock were made, and
+    # raise a Test::Unit::AssertionFailed exception otherwise.  This
+    # method will be called automatically if you use the methods provided
+    # by TestCaseHelpers
+    def verify
+      missing_expectations = @expectations - @satisfied_expectations
+      if missing_expectations.any?
+        raise AssertionFailedError.new("Expected #{missing_expectations[0]} did not happen")
+      end
+    end
+
+    # Execute the given block and call #verify afterwards.  You are unlikely
+    # to use this method, since the methods in TestCaseHelpers render it
+    # somewhat redundant.
+    def use &block
+      block.call(proxy)
+      verify
+    end
+
+    private
+
+    def create_proxy
+      @proxy = Object.new
+      @stubs = @proxy.instance_eval '@stubs = {}'
+    end
+
+    def stub_for(method_name)
+      mock_method = @stubs[method_name]
+      unless mock_method
+        mock_method = @stubs[method_name]= Response.new
+        install_method_in_proxy(method_name)
+      end
+      mock_method
+    end
+
+    def stub_call(method_name, *argspec)
+      stub_for(method_name).add_handler(CallMatcher.new(method_name, argspec))
+    end
+
+    def expect_call(method_name, *argspec)
+      handler = CallMatcher.new(method_name, argspec) do |satisfied|
+        if @satisfied_expectations.include?(satisfied)
+          raise AssertionFailedError.new("Unexpected extra call to #{method_name}")
+        end
+        @satisfied_expectations << satisfied
+      end
+      @expectations << stub_for(method_name).add_handler(handler)
+      handler
+    end
+
+    def install_method_in_proxy(method_name)
+      @proxy.instance_eval(<<-EOF)
+        def #{method_name.to_s}(*args, &block)
+          args << block if block
+          @stubs[:#{method_name}].call(*args)
+        end
+      EOF
+    end
+  end
+
+  ################################################################################
+  private
+  ################################################################################
+
+  class CallMatcher # :nodoc:
+
+    def initialize(method_name, argspec, &listener)
+      @method_name = method_name
+      @argspec = argspec
+      @response = lambda { }
+      @listener = listener
+    end
+
+    def ===(args)
+      return false if args.size > @argspec.size
+      @argspec.zip(args).each do |expected, actual|
+        return false unless expected === actual
+      end
+      true
+    end
+
+    def call
+      @listener.call(self) if @listener
+      @response.call
+    end
+
+    def to_s
+      "call to #{@method_name} with args #{@argspec.inspect}"
+    end
+
+    def as(&block)
+      @response = block
+    end
+  end
+
+  ################################################################################
+
+  class Response # :nodoc:
+    include ::Test::Unit
+
+    def initialize
+      @handlers = []
+    end
+
+    def add_handler(handler)
+      @handlers << handler; handler
+    end
+
+    def call(*args, &block)
+      args << block if block
+      @handlers.each do |handler|
+        return handler.call if handler === args
+      end
+      raise AssertionFailedError.new("no match for arguments: #{args.inspect}")
+    end
+  end
+
+  class CallRecorder # :nodoc:
+    def initialize(on_call)
+      @on_call = on_call
+    end
+    public_instance_methods.each do |meth|
+      undef_method(meth) unless %w(__id__ __send__ method_missing).include?(meth)
+    end
+    def method_missing(meth, *args)
+      @on_call.call(meth, *args)
+    end
+  end
+
+  # Include this module in your Test::Unit::TestCase in order to more conveniently
+  # use and verify mocks.
+  module TestCaseHelpers
+
+    # Create a new mock and remember it so that it can be automatically
+    # verified when the test case completes
+    def new_mock
+      @mocks ||= []
+      @mocks << (mock = Mock.new)
+      mock
+    end
+
+    alias mock new_mock
+
+    def teardown # :nodoc:
+      verify_all_mocks
+    end
+
+    # Verify all mocks that were created using #new_mock.
+    #
+    # Usually you will not
+    # need to call this method yourself -- it is called automatically unless
+    # you override #teardown for your own purposes
+    def verify_all_mocks
+      return unless instance_variables.include?("@mocks")
+      @mocks.each do |mock|
+        mock.verify
+      end
+    end
+
+  end
+
+end

data/test/mockr_tests.rb

@@ -0,0 +1,165 @@
+#!/usr/bin/env ruby
+$VERBOSE = true if $0 == __FILE__
+$:.unshift(File.dirname(__FILE__) + "/../lib")
+
+require 'test/unit'
+require 'mockr'
+
+
+module Mockr::Test
+
+  class MockTest < Test::Unit::TestCase
+    include ::Test::Unit
+    include Mockr
+
+    def test_stub_call_with_no_arguments_returns_nil
+      mock = Mock.new
+      mock.stubs.ping
+      assert_nil mock.proxy.ping
+    end
+
+    def test_stub_call_with_no_arguments_will_return_preset_value
+      mock = Mock.new
+      mock.stubs.ping.as {'pong'}
+      assert_equal 'pong', mock.proxy.ping
+    end
+
+    def test_can_construct_mock_with_a_block
+      mock = Mock.new do |m|
+        m.stubs.ping.as {'pong'}
+      end
+      assert_equal 'pong', mock.proxy.ping
+    end
+
+    def test_error_raised_if_missing_mock_method_invoked
+      proxy = Mock.new.proxy
+      assert_raise NoMethodError do proxy.ping end
+    end
+
+    def test_verify_after_calling_no_stubs_does_nothing
+      Mock.new.verify
+      Mock.new { |m| m.stubs.ping }.verify
+    end
+
+    def test_verify_after_calling_stubs_does_nothing
+      mock = Mock.new do |m| m.stubs.ping end
+      mock.proxy.ping
+      mock.verify
+    end
+
+    def test_can_expect_and_call_method_with_no_arguments
+      mock = Mock.new do |m| m.expects.bing end
+      assert_nil mock.proxy.bing
+    end
+
+    def test_verify_after_calling_expected_method_with_no_args
+      mock = Mock.new do |m| m.expects.bing end
+      mock.proxy.bing
+      mock.verify
+    end
+
+    def test_verify_fails_when_expected_method_not_called
+      mock = Mock.new do |m| m.expects.bing end
+      assert_raise AssertionFailedError do mock.verify end
+    end
+
+    def test_can_use_mock_with_block_in_order_to_have_verify_called_automatically
+      mock = Mock.new do |m|
+        m.expects.some_method
+        m.expects.some_other_method
+      end
+      assert_raise AssertionFailedError do
+        mock.use { |o| o.some_method }
+      end
+    end
+
+    def test_can_call_a_stub_twice
+      mock = Mock.new do |m| m.stubs.bing.as {'crosby'} end
+      2.times do assert_equal 'crosby', mock.proxy.bing end
+    end
+
+    def test_can_stub_a_method_with_an_argument
+      mock = Mock.new do |m| m.stubs.bing('who?').as {'crosby'} end
+      assert_equal 'crosby', mock.proxy.bing('who?')
+    end
+
+    def test_can_stub_a_method_twice_with_different_args
+      mock = Mock.new do |m|
+        m.stubs.last_name?('marlon').as {'brando'}
+        m.stubs.last_name?('jimmy').as {'cagney'}
+      end
+      assert_equal 'cagney', mock.proxy.last_name?('jimmy')
+      assert_equal 'brando', mock.proxy.last_name?('marlon')
+    end
+
+    def test_can_expect_a_method_with_an_argument
+      mock = Mock.new
+      mock.expects.who_am_i?('Jackie').as { 'Chan' }
+      mock.use do |o|
+        assert_equal 'Chan', o.who_am_i?('Jackie')
+      end
+    end
+
+    def test_error_raised_if_expected_method_called_twice
+      mock = Mock.new do |m| m.expects.some_method end
+      mock.proxy.some_method
+      assert_raise AssertionFailedError do mock.proxy.some_method end
+    end
+
+    def test_can_stub_pre_existing_methods
+      mock = Mock.new do |m| m.stubs.to_s.as {'foobar'} end
+      assert_equal 'foobar', mock.proxy.to_s
+    end
+
+    def test_can_stub_call_that_expects_a_block
+      mock = Mock.new do |m| m.stubs.each(Proc) end
+      mock.proxy.each {}
+    end
+
+    def test_error_raised_if_block_not_given_to_stubbed_method_wanting_a_block
+      mock = Mock.new do |m| m.stubs.each(Proc) end
+      assert_raise AssertionFailedError do
+        mock.proxy.each
+      end
+    end
+
+    def test_can_use_ranges_to_specify_argument_matches
+      mock = Mock.new do |m|
+        m.stubs.between_1_and_5?(1..5).as { true }
+        m.stubs.between_1_and_5?(6..10).as { false }
+      end
+      mock.use do |o|
+        assert_equal true, o.between_1_and_5?(3)
+        assert_equal false, o.between_1_and_5?(7)
+      end
+    end
+
+    def test_can_stub_constants
+      mock = Mock.new do |m| m.stubs.FOOBAR.as { "jimini" } end
+      assert_equal 'jimini', mock.proxy.FOOBAR
+    end
+
+    def test_can_expect_constants
+      mock = Mock.new do |m| m.expects.FOOBAR.as { "jimini" } end
+      assert_equal 'jimini', mock.proxy.FOOBAR
+    end
+
+  end
+
+#  class AutoMockTest < Test::Unit::TestCase
+#    include RMock::TestCaseHelpers
+#
+#    def test_foo
+#      m = new_mock
+#      m.expects.foo.as { 'bar' }
+#    end
+#
+#  end
+
+  # TODO:
+  #  * Clearer error messages
+  #  * Namespaces for constants
+  #  * Intercepting top-level calls such as File#open
+  #  * Explicit test for use of === in arg matching
+  #  * Allow specification of call order
+end

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: mockr
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+date: 2006-07-31 00:00:00 +02:00
+summary: Easy Mock Objects for Ruby.
+require_paths: 
+- lib
+email: 
+homepage: 
+rubyforge_project: 
+description: "MockR is a tiny mock object library inspired by JMock.  Main selling points: * Natural and unintrusive syntax * Supports the distinction between mocks and stubs * Constraint-based mechanism for matching call parameters See http://mockr.sanityinc.com/ for more info."
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: []
+
+files: 
+- lib/mockr.rb
+- test/mockr_tests.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: 
+- none
+dependencies: []
+