flexmock 0.1.1

data/test/test_example.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'flexmock'
+
+class TemperatureSampler
+  def initialize(sensor)
+    @sensor = sensor
+  end
+
+  def average_temp
+    total = (0...3).collect { @sensor.read_temperature }.inject { |i, s| i + s }
+    total / 3.0
+  end
+    
+end
+
+class TestTemperatureSampler < Test::Unit::TestCase
+  def test_tempurature_sampler
+    readings = [10, 12, 14]
+    mock_sensor = FlexMock.new
+    mock_sensor.mock_handle(:read_temperature) { readings.shift }
+    sampler = TemperatureSampler.new(mock_sensor)
+    assert_equal 12, sampler.average_temp
+  end
+end

data/test/test_mock.rb

@@ -0,0 +1,171 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'flexmock'
+
+class TestFlexMock < Test::Unit::TestCase
+  def setup
+    @mock = FlexMock.new
+  end
+
+  def test_handle
+    args = nil
+    @mock.mock_handle(:hi) { |a, b| args = [a,b] }
+    @mock.hi(1,2)
+    assert_equal [1,2], args
+  end
+
+  def test_handle_no_block
+    @mock.mock_handle(:blip)
+    @mock.blip
+    assert true, "just checking for failures"
+  end
+
+  def test_called_with_block
+    called = false
+    @mock.mock_handle(:blip) { |block| block.call }
+    @mock.blip { called = true }
+    assert called, "Block to blip should be called"
+  end
+
+  def test_return_value
+    @mock.mock_handle(:blip) { 10 }
+    assert_equal 10, @mock.blip
+  end
+
+  def test_handle_missing_method
+    expected_error = (VERSION >= "1.8.0") ? NoMethodError : NameError
+    ex = assert_raises(expected_error) {
+      @mock.not_defined
+    }
+    assert_match /not_defined/, ex.message
+  end
+
+  def test_ignore_missing_method
+    @mock.mock_ignore_missing
+    @mock.blip
+    assert true, "just checking for failures"
+  end
+
+  def test_good_counts
+    @mock.mock_handle(:blip, 3)
+    @mock.blip
+    @mock.blip
+    @mock.blip
+    @mock.mock_verify
+  end
+
+  def test_bad_counts
+    @mock.mock_handle(:blip, 3)
+    @mock.blip
+    @mock.blip
+    begin
+      @mock.mock_verify
+    rescue Test::Unit::AssertionFailedError => err
+    end
+    assert_not_nil err
+  end
+
+  def test_undetermined_counts
+    FlexMock.use('fs') { |m|
+      m.mock_handle(:blip)
+      m.blip
+      m.blip
+      m.blip
+    }
+  end
+
+  def test_zero_counts
+    assert_raises(Test::Unit::AssertionFailedError) do
+      FlexMock.use { |m|
+	m.mock_handle(:blip, 0)
+	m.blip
+      }
+    end
+  end
+
+  def test_file_io_with_use
+    file = FlexMock.use do |m|
+      filedata = ["line 1", "line 2"]
+      m.mock_handle(:gets, 3) { filedata.shift }
+      assert_equal 2, count_lines(m)
+    end
+  end
+
+  def count_lines(stream)
+    result = 0
+    while line = stream.gets
+      result += 1
+    end
+    result    
+  end
+
+  def test_use
+    assert_raises(Test::Unit::AssertionFailedError) {
+      FlexMock.use do |m|
+	m.mock_handle(:blip, 2)
+	m.blip
+      end
+    }
+  end
+
+  def test_failures_during_use
+    ex = assert_raises(NameError) {
+      FlexMock.use do |m|
+	m.mock_handle(:blip, 2)
+	xyz
+      end
+    }
+    assert_match /undefined local variable or method/, ex.message
+  end
+
+  def test_sequential_values
+    values = [1,4,9,16]
+    @mock.mock_handle(:get) { values.shift }
+    assert_equal 1, @mock.get
+    assert_equal 4, @mock.get
+    assert_equal 9, @mock.get
+    assert_equal 16, @mock.get
+  end
+  
+  def test_respond_to_returns_false_for_non_handled_methods
+    assert(!@mock.respond_to?(:blah), "should not respond to blah")
+  end
+
+  def test_respond_to_returns_true_for_explicit_methods
+    @mock.mock_handle(:xyz)
+    assert(@mock.respond_to?(:xyz), "should respond to test")
+  end
+
+  def test_respond_to_returns_true_for_missing_methods_when_ignoring_missing
+    @mock.mock_ignore_missing
+    assert(@mock.respond_to?(:yada), "should respond to yada now")
+  end
+
+  def test_respond_to_returns_true_for_missing_methods_when_ignoring_missing_using_should
+    @mock.should_ignore_missing
+    assert(@mock.respond_to?(:yada), "should respond to yada now")
+  end
+
+  def test_method_proc_raises_error_on_unknown
+    assert_raises(NameError) {
+      @mock.method(:xyzzy)
+    }
+  end
+
+  def test_method_returns_callable_proc
+    got_it = false
+    @mock.mock_handle(:xyzzy) { got_it = true }
+    method_proc = @mock.method(:xyzzy)
+    assert_not_nil method_proc
+    method_proc.call
+    assert(got_it, "method proc should run")
+  end
+
+  def test_method_returns_do_nothing_proc_for_missing_methods
+    @mock.mock_ignore_missing
+    method_proc = @mock.method(:plugh)
+    assert_not_nil method_proc
+    method_proc.call
+  end
+end

data/test/test_naming.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'flexmock'
+
+class TestNaming < Test::Unit::TestCase
+  def test_name
+    m = FlexMock.new("m")
+    assert_equal "m", m.mock_name
+  end
+
+  def test_name_in_no_handler_found_error
+    m = FlexMock.new("mmm")
+    ex = assert_raises(Test::Unit::AssertionFailedError) {
+      m.should_receive(:xx).with(1)
+      m.xx(2)
+    }
+    assert_match /'mmm'/, ex.message
+  end
+
+  def test_name_in_received_count_error
+    m = FlexMock.new("mmm")
+    ex = assert_raises(Test::Unit::AssertionFailedError) {
+      m.should_receive(:xx).once
+      m.mock_verify
+    }
+    assert_match /'mmm'/, ex.message
+  end
+
+  def test_naming_with_use
+    FlexMock.use("blah") do |m|
+      assert_equal "blah", m.mock_name
+    end
+  end
+
+  def test_naming_with_multiple_mocks_in_use
+    FlexMock.use("blah", "yuk") do |a, b|
+      assert_equal "blah", a.mock_name
+      assert_equal "yuk",  b.mock_name
+    end
+  end
+end

data/test/test_samples.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+
+#---
+# Copyright 2003 by Jim Weirich (jweirich@one.net).
+# All rights reserved.
+
+# Permission is granted for use, copying, modification, distribution,
+# and distribution of modified versions of this work as long as the
+# above copyright notice is included.
+#+++
+
+require 'test/unit'
+
+# Sample FlexMock Usage.
+
+class TestSamples < Test::Unit::TestCase
+
+  # This is a basic example where we setup a mock object to mimic an
+  # IO object.  We know that the +count_lines+ method uses gets, so we
+  # tell the mock object to handle +gets+ by returning successive
+  # elements of an array (just as the real +gets+ returns successive
+  # elements of a file.
+  def test_file_io
+    file = FlexMock.new
+    filedata = ["line 1", "line 2"]
+    file.mock_handle(:gets) { filedata.shift }
+    assert_equal 2, count_lines(file)
+  end
+
+  # Count the number of lines in a file.  Used in the test_file_io
+  # test.
+  def count_lines(file)
+    n = 0
+    while file.gets
+      n += 1
+    end
+    n
+  end
+
+  def test_x
+  end
+end
+

data/test/test_should_receive.rb

@@ -0,0 +1,443 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'flexmock'
+
+class TestFlexMock < Test::Unit::TestCase
+
+  def test_defaults
+    FlexMock.use do |m|
+      m.should_receive(:hi)
+      assert_nil m.hi
+      assert_nil m.hi(1)
+      assert_nil m.hi("hello", 2)
+    end
+  end
+
+  def test_returns_with_value
+    FlexMock.use do |m|
+      m.should_receive(:hi).returns(1)
+      assert_equal 1, m.hi
+      assert_equal 1, m.hi(123)
+    end
+  end
+
+  def test_returns_with_block
+    FlexMock.use do |m|
+      result = nil
+      m.should_receive(:hi).with(Object).returns { |obj| result = obj }
+      m.hi(3)
+      assert_equal 3, result
+    end
+  end
+
+  def test_and_returns_alias
+    FlexMock.use do |m|
+      m.should_receive(:hi).and_return(4)
+      assert_equal 4, m.hi
+    end
+  end
+
+  def test_multiple_expectations
+    FlexMock.use do |m|
+      m.should_receive(:hi).with(1).returns(10)
+      m.should_receive(:hi).with(2).returns(20)
+      
+      assert_equal 10, m.hi(1)
+      assert_equal 20, m.hi(2)
+    end
+  end
+
+  def test_with_no_args_with_no_args
+    FlexMock.use do |m|
+      m.should_receive(:hi).with_no_args
+      m.hi
+    end
+  end
+
+  def test__with_no_args_but_with_args
+    ex = assert_failure do
+      FlexMock.use do |m|
+	m.should_receive(:hi).with_no_args
+	m.hi(1)
+      end
+    end
+  end
+
+  def test__with_any_args
+    FlexMock.use do |m|
+      m.should_receive(:hi).with_any_args
+      m.hi
+      m.hi(1)
+      m.hi(1,2,3)
+      m.hi("this is a test")
+    end
+  end
+
+  def test_args_matching_with_regex
+    FlexMock.use do |m|
+      m.should_receive(:hi).with(/one/).returns(10)
+      m.should_receive(:hi).with(/t/).returns(20)
+      
+      assert_equal 10, m.hi("one")
+      assert_equal 10, m.hi("done")
+      assert_equal 20, m.hi("two")
+      assert_equal 20, m.hi("three")
+    end
+  end
+
+  def test_arg_matching_with_regex_matching_non_string
+    FlexMock.use do |m|
+      m.should_receive(:hi).with(/1/).returns(10)
+      assert_equal 10, m.hi(319)
+    end
+  end
+
+  def test_arg_matching_with_class
+    FlexMock.use do |m|
+      m.should_receive(:hi).with(Fixnum).returns(10)
+      m.should_receive(:hi).with(Object).returns(20)
+      
+      assert_equal 10, m.hi(319)
+      assert_equal 10, m.hi(Fixnum)
+      assert_equal 20, m.hi("hi")
+    end
+  end
+
+  def test_arg_matching_with_no_match
+    FlexMock.use do |m|
+      m.should_receive(:hi).with(1).returns(10)
+      assert_failure {
+	assert_equal 20, m.hi(2)
+      }
+    end
+  end
+
+  def test_never_and_never_called
+    FlexMock.use do |m|
+      m.should_receive(:hi).with(1).never
+    end
+  end
+
+  def test_never_and_called_once
+    ex = assert_failure do    
+      FlexMock.use do |m|
+	m.should_receive(:hi).with(1).never
+	m.hi(1)
+      end
+    end
+  end
+
+  def test_once_called_once
+    FlexMock.use do |m|
+      m.should_receive(:hi).with(1).returns(10).once
+      m.hi(1)
+    end
+  end
+
+  def test_once_but_never_called
+    ex = assert_failure do
+      FlexMock.use do |m|
+	m.should_receive(:hi).with(1).returns(10).once
+      end
+    end
+  end
+
+  def test_once_but_called_twice
+    ex = assert_failure do
+      FlexMock.use do |m|
+	m.should_receive(:hi).with(1).returns(10).once
+	m.hi(1)
+	m.hi(1)
+      end
+    end
+  end
+
+  def test_twice_and_called_twice
+    FlexMock.use do |m|
+      m.should_receive(:hi).with(1).returns(10).twice
+      m.hi(1)
+      m.hi(1)
+    end
+  end
+
+  def test_zero_or_more_called_zero
+    FlexMock.use do |m|
+      m.should_receive(:hi).zero_or_more_times
+    end
+  end
+
+  def test_zero_or_more_called_once
+    FlexMock.use do |m|
+      m.should_receive(:hi).zero_or_more_times
+      m.hi
+    end
+  end
+
+  def test_zero_or_more_called_100
+    FlexMock.use do |m|
+      m.should_receive(:hi).zero_or_more_times
+      100.times { m.hi }
+    end
+  end
+
+  def test_times
+    FlexMock.use do |m|
+      m.should_receive(:hi).with(1).returns(10).times(10)
+      10.times { m.hi(1) }
+    end
+  end
+
+  def test_at_least_called_once
+    FlexMock.use do |m|
+      m.should_receive(:hi).with(1).returns(10).at_least.once
+      m.hi(1)
+    end
+  end
+
+  def test_at_least_but_never_called
+    ex = assert_failure do
+      FlexMock.use do |m|
+	m.should_receive(:hi).with(1).returns(10).at_least.once
+      end
+    end
+  end
+
+  def test_at_least_once_but_called_twice
+    FlexMock.use do |m|
+      m.should_receive(:hi).with(1).returns(10).at_least.once
+      m.hi(1)
+      m.hi(1)
+    end
+  end
+
+  def test_at_least_and_exact
+    ex = assert_failure do
+      FlexMock.use do |m|
+	m.should_receive(:hi).with(1).returns(10).at_least.once.once
+	m.hi(1)
+	m.hi(1)
+      end
+    end
+  end
+
+  def test_at_most_but_never_called
+    FlexMock.use do |m|
+      m.should_receive(:hi).with(1).returns(10).at_most.once
+    end
+  end
+
+  def test_at_most_called_once
+    FlexMock.use do |m|
+      m.should_receive(:hi).with(1).returns(10).at_most.once
+      m.hi(1)
+    end
+  end
+
+  def test_at_most_called_twice
+    ex = assert_failure do
+      FlexMock.use do |m|
+	m.should_receive(:hi).with(1).returns(10).at_most.once
+	m.hi(1)
+	m.hi(1)
+      end
+    end
+  end
+
+  def test_at_most_and_at_least_called_never
+    ex = assert_failure do
+      FlexMock.use do |m|
+	m.should_receive(:hi).with(1).returns(10).at_least.once.at_most.twice
+      end
+    end
+  end
+
+  def test_at_most_and_at_least_called_once
+    FlexMock.use do |m|
+      m.should_receive(:hi).with(1).returns(10).at_least.once.at_most.twice
+      m.hi(1)
+    end
+  end
+
+  def test_at_most_and_at_least_called_twice
+    FlexMock.use do |m|
+      m.should_receive(:hi).with(1).returns(10).at_least.once.at_most.twice
+      m.hi(1)
+      m.hi(1)
+    end
+  end
+
+  def test_at_most_and_at_least_called_three_times
+    ex = assert_failure do
+      FlexMock.use do |m|
+	m.should_receive(:hi).with(1).returns(10).at_least.once.at_most.twice
+	m.hi(1)
+	m.hi(1)
+	m.hi(1)
+      end
+    end
+  end
+
+  def test_call_counts_only_apply_to_matching_args
+    FlexMock.use do |m|
+      m.should_receive(:hi).with(1).once
+      m.should_receive(:hi).with(2).twice
+      m.should_receive(:hi).with(3)
+      m.hi(1)
+      m.hi(2)
+      m.hi(2)
+      20.times { m.hi(3) }
+    end
+  end
+
+  def test_call_counts_only_apply_to_matching_args_with_mismatch
+    ex = assert_failure do
+      FlexMock.use do |m|
+	m.should_receive(:hi).with(1).once
+	m.should_receive(:hi).with(2).twice
+	m.should_receive(:hi).with(3)
+	m.should_receive(:lo)
+	m.hi(1)
+	m.hi(2)
+	m.lo
+	20.times { m.hi(3) }
+      end
+    end
+  end
+
+  def test_ordered_calls_in_order
+    FlexMock.use 'm' do |m|
+      m.should_receive(:hi).ordered
+      m.should_receive(:lo).ordered
+
+      m.hi
+      m.lo
+    end
+  end
+
+  def test_ordered_calls_out_of_order
+    ex = assert_failure do
+      FlexMock.use 'm' do |m|
+	m.should_receive(:hi).ordered
+	m.should_receive(:lo).ordered
+	
+	m.lo
+	m.hi
+      end
+    end
+  end
+
+  def test_order_calls_with_different_arg_lists_and_in_order
+    FlexMock.use 'm' do |m|
+      m.should_receive(:hi).with("one").ordered
+      m.should_receive(:hi).with("two").ordered
+      
+      m.hi("one")
+      m.hi("two")
+    end
+  end
+
+  def test_order_calls_with_different_arg_lists_and_out_of_order
+    ex = assert_failure do
+      FlexMock.use 'm' do |m|
+	m.should_receive(:hi).with("one").ordered
+	m.should_receive(:hi).with("two").ordered
+	
+	m.hi("two")
+	m.hi("one")
+      end
+    end
+  end
+
+  def test_unordered_calls_do_not_effect_ordered_testing
+    FlexMock.use 'm' do |m|
+      m.should_receive(:blah)
+      m.should_receive(:hi).ordered
+      m.should_receive(:lo).ordered
+      
+      m.blah
+      m.hi
+      m.blah
+      m.lo
+      m.blah
+    end
+  end
+
+  def test_ordered_with_multiple_calls_is_ok
+    FlexMock.use 'm' do |m|
+      m.should_receive(:hi).ordered
+      m.should_receive(:lo).ordered
+      
+      m.hi
+      m.hi
+      m.lo
+      m.lo
+    end
+  end
+
+  def test_explicit_ordering
+    FlexMock.use 'm' do |m|
+      m.should_receive(:start).ordered(2)
+      m.should_receive(:flip).ordered(10)
+      m.should_receive(:flop).ordered(10)
+      m.should_receive(:final).ordered
+      
+      m.start
+      m.flop
+      m.flip
+      m.flop
+      m.final
+    end
+  end
+
+  def test_explicit_ordering_mixed_with_implicit_ordering_should_not_overlap
+    FlexMock.use 'm' do |m|
+      xstart = m.should_receive(:start).ordered
+      xmid = m.should_receive(:mid).ordered(2)
+      xend = m.should_receive(:end).ordered
+      assert xstart.order_number < xmid.order_number
+      assert xmid.order_number < xend.order_number
+    end
+  end
+
+  def test_explicit_ordering_with_overlap_with_start
+    ex = assert_failure do
+      FlexMock.use 'm' do |m|
+	xstart = m.should_receive(:start).ordered
+	xmid = m.should_receive(:mid).ordered(1)
+      end
+    end
+  end
+
+  def test_explicit_ordering_with_explicit_misorders
+    assert_failure do 
+      FlexMock.use 'm' do |m|
+	m.should_receive(:hi).ordered(2)
+	m.should_receive(:lo).ordered(10)
+	
+	m.lo
+	m.hi
+      end
+    end
+  end
+
+  def test_explicit_ordering_with_out_of_order_explicitness
+    assert_failure do
+      FlexMock.use 'm' do |m|
+	m.should_receive(:lo).ordered(10)
+	m.should_receive(:hi).ordered(2)
+      end
+    end
+  end
+
+  def test_expectation_formating
+    m = FlexMock.new("m")
+    exp = m.should_receive(:f).with(1,"two", /^3$/).and_return(0).at_least.once
+    assert_equal 'f(1, "two", /^3$/)', exp.to_s
+  end
+
+  def assert_failure
+    assert_raises(Test::Unit::AssertionFailedError) do yield end
+  end
+
+end