Mocha Ruby Library

Partial Mocking allows you to apply stubs or expectations to existing, real objects or classes. This is useful when you want to keep most of an object's original behavior but override specific methods.

Key patterns:

• Stubbing an instance method: object.stubs(:method).returns(value)
• Stubbing a class method: Class.stubs(:method).returns(value)
• Stubbing all instances of a class: Class.any_instance.stubs(:method).returns(value)

require 'test/unit'
require 'mocha/test_unit'

class OrderTest < Test::Unit::TestCase
  # illustrates stubbing instance method
  def test_should_calculate_shipping_cost_based_on_total_weight
    order = Order.new
    order.stubs(:total_weight).returns(10)
    assert_equal 60, order.shipping_cost
  end

  # illustrates stubbing class method
  def test_should_count_number_of_orders_shipped_after_specified_date
    now = Time.now; week_in_secs = 7 * 24 * 60 * 60
    order_1 = Order.new; order_1.shipped_on = now - 1 * week_in_secs
    order_2 = Order.new; order_2.shipped_on = now - 2 * week_in_secs
    Order.stubs(:find_all).returns([order_1, order_2])
    assert_equal 1, Order.number_shipped_since(now - 2 * week_in_secs)
  end

  # illustrates stubbing instance method for all instances of a class
  def test_should_calculate_value_of_unshipped_orders
    Order.stubs(:find_all).returns([Order.new, Order.new, Order.new])
    Order.any_instance.stubs(:shipped_on).returns(nil)
    Order.any_instance.stubs(:total_cost).returns(10)
    assert_equal 30, Order.unshipped_value
  end
end

Mocha is a mocking and stubbing framework built around several key abstractions that compose to allow fine-grained control over object behavior during tests:

1. API: Provides the entry points for creating mocks and stubs. Methods from the API are automatically injected into Test::Unit::TestCase and Minitest::Unit::TestCase via adapters.
2. Mock Creation: You create test doubles using mock, stub, or stub_everything. These methods return a Mock object.
3. Expectations: Once you have a Mock, you use #expects (to define a required call) or #stubs (to define a method that can be called zero or more times). Both methods return an Expectation object.
4. Expectation Fluent Interface: An Expectation can be further refined using a fluent interface to specify return values, error raising, or call counts.
5. Parameter Matchers: You can use ParameterMatchers within Expectation#with to restrict which specific arguments will trigger a match for that expectation.

Integration adapters provide built-in support for Minitest and Test::Unit, while integration hooks allow for support in other test frameworks.

Mocha provides several ways to create test doubles:

• Mocking a class method: Use expects on the class.
• Mocking an instance method on a real object: Use expects on the instance.
• Stubbing instance methods on real objects: Use stubs on the instance.
• Stubbing instance methods on all instances of a class: Use any_instance.stubs.
• Traditional Mocking: Create a new mock object using mock('name').
• Shortcuts: Create a stub object with predefined methods using stub(method: value).

require 'test/unit'
require 'mocha/test_unit'

class MiscExampleTest < Test::Unit::TestCase
  def test_mocking_a_class_method
    product = Product.new
    Product.expects(:find).with(1).returns(product)
    assert_equal product, Product.find(1)
  end

  def test_mocking_an_instance_method_on_a_real_object
    product = Product.new
    product.expects(:save).returns(true)
    assert product.save
  end

  def test_stubbing_instance_methods_on_real_objects
    prices = [stub(pence: 1000), stub(pence: 2000)]
    product = Product.new
    product.stubs(:prices).returns(prices)
    assert_equal [1000, 2000], product.prices.collect {|p| p.pence}
  end

  def test_stubbing_an_instance_method_on_all_instances_of_a_class
    Product.any_instance.stubs(:name).returns('stubbed_name')
    product = Product.new
    assert_equal 'stubbed_name', product.name
  end

  def test_traditional_mocking
    object = mock('object')
    object.expects(:expected_method).with(:p1, :p2).returns(:result)
    assert_equal :result, object.expected_method(:p1, :p2)
  end

  def test_shortcuts
    object = stub(method1: :result1, method2: :result2)
    assert_equal :result1, object.method1
    assert_equal :result2, object.method2
  end
end