flexmock 0.6.4 → 0.7.0

data/test/test_new_instances.rb

@@ -11,9 +11,11 @@
 
 require 'test/unit'
 require 'flexmock'
+require 'test/redirect_error'
 
 class TestNewInstances < Test::Unit::TestCase
   include FlexMock::TestCase
+  include FlexMock::RedirectError
   
   class Dog
     def bark
@@ -55,17 +57,6 @@ class TestNewInstances < Test::Unit::TestCase
     assert_equal :whimper,  m.bark
   end
   
-  def test_any_instance_still_works_for_backwards_compatibility
-    message = redirect_error { 
-      flexstub(Dog).any_instance do |obj|
-        obj.should_receive(:bark).and_return(:whimper)
-        assert_match(/deprecated/, message)
-      end
-    }
-    m = Dog.new
-    assert_equal :whimper,  m.bark   
-  end
-  
   def test_new_instances_stubs_still_have_existing_methods
     flexstub(Dog).new_instances do |obj|
       obj.should_receive(:bark).and_return(:whimper)
@@ -214,17 +205,6 @@ class TestNewInstances < Test::Unit::TestCase
     dog.bite
     dog.bark
   end
-  
-  def redirect_error
-    require 'stringio'
-    old_err = $stderr
-    $stderr = StringIO.new
-    yield
-    $stderr.string
-  rescue
-    $stderr = old_err
-  end
-  private :redirect_error
 end
 
 

data/test/test_partial_mock.rb

@@ -64,7 +64,7 @@ class TestStubbing < Test::Unit::TestCase
     partial_mock = flexmock(dog)
     partial_mock.should_receive(:bark).once.and_return(:growl)
     assert_equal :growl, dog.bark
-    partial_mock.mock_teardown
+    partial_mock.flexmock_teardown
     assert_equal :woof, dog.bark
     assert_equal nil, dog.instance_variable_get("@flexmock_proxy")
   end
@@ -74,7 +74,7 @@ class TestStubbing < Test::Unit::TestCase
     partial_mock = flexmock(obj)
     partial_mock.should_receive(:hi).once.and_return(:ok)
     assert_equal :ok, obj.hi
-    partial_mock.mock_teardown
+    partial_mock.flexmock_teardown
     assert_raise(NoMethodError) { obj.hi }
   end
 
@@ -85,7 +85,7 @@ class TestStubbing < Test::Unit::TestCase
     partial_mock.should_receive(:hi).with(2).once.and_return(:ok)
     assert_equal :ok, obj.hi(1)
     assert_equal :ok, obj.hi(2)
-    partial_mock.mock_teardown
+    partial_mock.flexmock_teardown
     assert_raise(NoMethodError) { obj.hi }
   end
   
@@ -93,7 +93,7 @@ class TestStubbing < Test::Unit::TestCase
     dog = Dog.new
     flexmock(dog).should_receive(:bark).and_return(:grrrr)
     flexmock(dog).should_receive(:wag).and_return(:happy)
-    flexmock(dog).mock_teardown
+    flexmock(dog).flexmock_teardown
     assert_equal :woof, dog.bark
     assert_raise(NoMethodError) { dog.wag }
   end
@@ -101,7 +101,7 @@ class TestStubbing < Test::Unit::TestCase
   def test_original_behavior_is_restored_on_class_objects
     flexmock(Dog).should_receive(:create).once.and_return(:new_stub)
     assert_equal :new_stub, Dog.create
-    flexmock(Dog).mock_teardown
+    flexmock(Dog).flexmock_teardown
     assert_equal :new_dog, Dog.create    
   end
 
@@ -111,7 +111,7 @@ class TestStubbing < Test::Unit::TestCase
     flexmock(obj).should_receive(:hi).once.and_return(:hola)
 
     assert_equal :hola, obj.hi
-    flexmock(obj).mock_teardown
+    flexmock(obj).flexmock_teardown
     assert_equal :hello, obj.hi
   end
 
@@ -123,7 +123,7 @@ class TestStubbing < Test::Unit::TestCase
 
     assert_equal :hola, obj.hi(1)
     assert_equal :hola, obj.hi(2)
-    flexmock(obj).mock_teardown
+    flexmock(obj).flexmock_teardown
     assert_equal "hello3", obj.hi(3)
   end
 
@@ -133,7 +133,7 @@ class TestStubbing < Test::Unit::TestCase
     assert_equal :ok1, Dir.chdir("xx")
     assert_equal :ok2, Dir.chdir("yy")
 
-    flexmock(Dir).mock_teardown
+    flexmock(Dir).flexmock_teardown
 
     x = :not_called
     Dir.chdir("test") do
@@ -146,7 +146,7 @@ class TestStubbing < Test::Unit::TestCase
   def test_stubbing_file_shouldnt_break_writing
     flexmock(File).should_receive(:open).with("foo").once.and_return(:ok)
     assert_equal :ok, File.open("foo")
-    flexmock(File).mock_teardown
+    flexmock(File).flexmock_teardown
 
     File.open("dummy.txt", "w") do |out|
       assert out.is_a?(IO)
@@ -166,15 +166,15 @@ class TestStubbing < Test::Unit::TestCase
 
     # Now disable the mock so that it doesn't cause errors on normal
     # test teardown
-    m = flexmock(Dog).mock
-    def m.mock_verify() end
+    m = flexmock(Dog).flexmock_get
+    def m.flexmock_verify() end
   end
 
   def test_not_calling_stubbed_method_is_an_error
     dog = Dog.new
     flexmock(dog).should_receive(:bark).once
     assert_raise(Test::Unit::AssertionFailedError) { 
-      flexmock(dog).mock_verify
+      flexmock(dog).flexmock_verify
     }
     dog.bark
   end
@@ -184,20 +184,20 @@ class TestStubbing < Test::Unit::TestCase
     partial_mock = flexmock(obj)
     partial_mock.should_receive(:hi).once.and_return(:ok)
     assert_raise(Test::Unit::AssertionFailedError) { 
-      partial_mock.mock_verify
+      partial_mock.flexmock_verify
     }
   end
   
   def test_stub_can_have_explicit_name
     obj = Object.new
     partial_mock = flexmock(obj, "Charlie")
-    assert_equal "Charlie", partial_mock.mock.mock_name
+    assert_equal "Charlie", partial_mock.flexmock_get.flexmock_name
   end
 
   def test_unamed_stub_will_use_default_naming_convention
     obj = Object.new
     partial_mock = flexmock(obj)
-    assert_equal "flexmock(Object)", partial_mock.mock.mock_name
+    assert_equal "flexmock(Object)", partial_mock.flexmock_get.flexmock_name
   end
 
   def test_partials_can_be_defined_in_a_block
@@ -223,7 +223,7 @@ class TestStubbing < Test::Unit::TestCase
 
   MOCK_METHOD_SUBSET = [
     :should_receive, :new_instances,
-    :mock, :mock_teardown, :mock_verify,
+    :flexmock_get,   :flexmock_teardown, :flexmock_verify,
   ]
 
   def test_domain_objects_do_not_have_mock_methods
@@ -244,7 +244,7 @@ class TestStubbing < Test::Unit::TestCase
   def test_partial_mocks_do_not_have_mock_methods_after_teardown
     dog = Dog.new
     flexmock(dog)
-    dog.mock_teardown
+    dog.flexmock_teardown
     MOCK_METHOD_SUBSET.each do |sym|
       assert ! dog.respond_to?(sym), "should not have :#{sym} defined"
     end
@@ -254,7 +254,7 @@ class TestStubbing < Test::Unit::TestCase
     dog = Dog.new
     def dog.mock() :original end
     flexmock(dog)
-    dog.mock_teardown
+    dog.flexmock_teardown
     assert_equal :original, dog.mock
   end
 
@@ -267,7 +267,7 @@ class TestStubbing < Test::Unit::TestCase
   def test_partial_mocks_with_mock_method_non_singleton_colision_have_original_defs_restored
     mc = MockColision.new
     flexmock(mc)
-    mc.mock_teardown
+    mc.flexmock_teardown
     assert_equal :original, mc.mock
   end
 

data/test/test_record_mode.rb

@@ -11,39 +11,29 @@
 
 require 'test/unit'
 require 'flexmock'
-
-module FailureAssertion
-  private
-  def assert_fails
-    assert_raise(Test::Unit::AssertionFailedError) do
-      yield
-    end
-  end
-end
+require 'test/asserts'
 
 class TestRecordMode < Test::Unit::TestCase
-  include FlexMock::ArgumentTypes
-  include FailureAssertion
+  include FlexMock::TestCase
+  include FlexMock::FailureAssertion
 
   def test_recording_mode_works
-    FlexMock.use("mock") do |mock|
-      mock.should_expect do |r|
-        r.f { :answer }
-      end
-      assert_equal :answer, mock.f
+    mock = flexmock("mock")
+    mock.should_expect do |recorder|
+      recorder.f { :answer }
     end
+    assert_equal :answer, mock.f
   end
 
   def test_arguments_are_passed_to_recording_mode_block
-    FlexMock.new("mock") do |mock|
-      mock.should_expect do |recorder|
-        recorder.f do |arg|
-          assert_equal :arg, arg
-          :answer
-        end
+    mock = flexmock("mock")
+    mock.should_expect do |recorder|
+      recorder.f(:arg) do |arg|
+        assert_equal :arg, arg
+        :answer
       end
-      assert_equal :answer, f(:arg)
     end
+    assert_equal :answer, mock.f(:arg)
   end
 
   def test_recording_mode_handles_multiple_returns
@@ -69,20 +59,19 @@ class TestRecordMode < Test::Unit::TestCase
   end
 
   def test_recording_mode_gets_block_args_too
-    FlexMock.use("mock") do |mock|
-      mock.should_expect do |r|
-        r.f(1, Proc) { |arg, block|
-          assert_not_nil block
-          block.call
-        }
-      end
-
-      assert_equal :block_result, mock.f(1) { :block_result }
+    mock = flexmock("mock")
+    mock.should_expect do |r|
+      r.f(1, Proc) { |arg, block|
+        assert_not_nil block
+        block.call
+      }
     end
+
+    assert_equal :block_result, mock.f(1) { :block_result }
   end
 
   def test_recording_mode_should_validate_args_with_equals
-    assert_fails do
+    assert_failure do
       FlexMock.use("mock") do |mock|
         mock.should_expect do |r|
           r.f(1)
@@ -93,7 +82,7 @@ class TestRecordMode < Test::Unit::TestCase
   end
 
   def test_recording_mode_should_allow_arg_contraint_validation
-    assert_fails do
+    assert_failure do 
       FlexMock.use("mock") do |mock|
         mock.should_expect do |r|
           r.f(1)
@@ -104,7 +93,7 @@ class TestRecordMode < Test::Unit::TestCase
   end
 
   def test_recording_mode_should_handle_multiplicity_contraints
-    assert_fails do
+    assert_failure do
       FlexMock.use("mock") do |mock|
         mock.should_expect do |r|
           r.f { :result }.once
@@ -116,7 +105,7 @@ class TestRecordMode < Test::Unit::TestCase
   end
 
   def test_strict_record_mode_requires_exact_argument_matches
-    assert_fails do
+    assert_failure do
       FlexMock.use("mock") do |mock|
         mock.should_expect do |rec|
           rec.should_be_strict
@@ -128,7 +117,7 @@ class TestRecordMode < Test::Unit::TestCase
   end
 
   def test_strict_record_mode_requires_exact_ordering
-    assert_fails do
+    assert_failure do
       FlexMock.use("mock") do |mock|
         mock.should_expect do |rec|
           rec.should_be_strict
@@ -142,7 +131,7 @@ class TestRecordMode < Test::Unit::TestCase
   end
 
   def test_strict_record_mode_requires_once
-    assert_fails do
+    assert_failure do
       FlexMock.use("mock") do |mock|
         mock.should_expect do |rec|
           rec.should_be_strict

data/test/test_should_receive.rb

@@ -24,6 +24,8 @@ module Kernel
 end
 
 class TestFlexMockShoulds < Test::Unit::TestCase
+  include FlexMock::TestCase
+  include FlexMock::FailureAssertion
 
   # Expected error messages on failures
   COUNT_ERROR_MESSAGE = /\bcalled\s+incorrect\s+number\s+of\s+times\b/
@@ -31,6 +33,7 @@ class TestFlexMockShoulds < Test::Unit::TestCase
   AT_LEAST_ERROR_MESSAGE = /\bshould\s+be\s+called\s+at\s+least\b/
   AT_MOST_ERROR_MESSAGE = /\bshould\s+be\s+called\s+at\s+most\b/
   OUT_OF_ORDER_ERROR_MESSAGE = /\bcalled\s+out\s+of\s+order\b/
+  NON_CONTAINER_MESSAGE = /\bis\s+not\s+in\s+a\s+container\b/
   
   def test_defaults
     FlexMock.use do |m|
@@ -60,6 +63,17 @@ class TestFlexMockShoulds < Test::Unit::TestCase
     end
   end
 
+  def test_multiple_returns
+    FlexMock.use do |m|
+      m.should_receive(:hi).and_return(1).and_return(2,3)
+      assert_equal 1, m.hi
+      assert_equal 2, m.hi
+      assert_equal 3, m.hi
+      assert_equal 3, m.hi
+      assert_equal 3, m.hi
+    end
+  end
+
   def test_returns_with_block
     FlexMock.use do |m|
       result = nil
@@ -69,6 +83,16 @@ class TestFlexMockShoulds < Test::Unit::TestCase
     end
   end
 
+  def test_return_with_and_without_block_interleaved
+    FlexMock.use do |m|
+      m.should_receive(:hi).and_return(:a).and_return { :b }.and_return(:c)
+      assert_equal :a, m.hi
+      assert_equal :b, m.hi
+      assert_equal :c, m.hi
+      assert_equal :c, m.hi
+    end
+  end
+
   def test_and_returns_alias
     FlexMock.use do |m|
       m.should_receive(:hi).and_return(4)
@@ -76,6 +100,83 @@ class TestFlexMockShoulds < Test::Unit::TestCase
     end
   end
 
+  def test_and_yield_will_continue_to_yield_the_same_value
+    FlexMock.use do |m|
+      m.should_receive(:hi).and_yield(:yield_value)
+      assert_equal :yield_value, m.hi { |v| v }
+      assert_equal :yield_value, m.hi { |v| v }
+    end
+  end
+
+  def test_and_yield_with_multiple_values_yields_the_values
+    FlexMock.use do |m|
+      m.should_receive(:hi).and_yield(:one, :two).once
+      assert_equal [:one, :two], m.hi { |a, b| [a, b] }
+    end
+  end
+
+  def test_multiple_yields_are_done_sequentially
+    FlexMock.use do |m|
+      m.should_receive(:msg).and_yield(:one).and_yield(:two)
+      assert_equal :one, m.msg { |a| a }
+      assert_equal :two, m.msg { |a| a }
+      assert_equal :two, m.msg { |a| a }
+    end
+  end
+
+  def test_failure_if_no_block_given
+    FlexMock.use do |m|
+      m.should_receive(:hi).and_yield(:one, :two).once
+      assert_raise(FlexMock::MockError) do m.hi end
+    end
+  end
+
+  def test_failure_different_return_value_than_yield_return
+    FlexMock.use do |m|
+      m.should_receive(:hi).and_yield(:yld).once.and_return(:ret)
+      yielded_value = nil
+      assert_equal :ret, m.hi { |v| yielded_value = v }
+      assert_equal :yld, yielded_value
+    end
+  end
+
+  def test_multiple_yields
+    FlexMock.use do |m|
+      m.should_receive(:hi).and_yield(:one, :two).and_yield(1, 2)
+      assert_equal [:one, :two], m.hi { |a, b| [a, b] }
+      assert_equal [1, 2], m.hi { |a, b| [a, b] }
+    end
+  end
+
+  def test_multiple_yields_will_yield_the_last_value_set
+    FlexMock.use do |m|
+      m.should_receive(:hi).and_yield(:a).and_yield(:b)
+      assert_equal [:a], m.hi { |a, b| [a] }
+      assert_equal [:b], m.hi { |a, b| [a] }
+      assert_equal [:b], m.hi { |a, b| [a] }
+      assert_equal [:b], m.hi { |a, b| [a] }
+      assert_equal [:b], m.hi { |a, b| [a] }
+    end
+  end
+
+  def test_yielding_then_not_yielding_and_then_yielding_again
+    FlexMock.use do |m|
+      m.should_receive(:hi).and_yield(:a).once
+      m.should_receive(:hi).and_return(:b).once
+      m.should_receive(:hi).and_yield(:c).once
+      assert_equal :a, m.hi { |v| v }
+      assert_equal :b, m.hi
+      assert_equal :c, m.hi { |v| v }
+    end
+  end
+
+  def test_yields_syntax
+    FlexMock.use do |m|
+      m.should_receive(:hi).yields(:one)
+      assert_equal :one, m.hi { |a| a }
+    end
+  end
+
   class MyError < RuntimeError
   end
 
@@ -118,6 +219,63 @@ class TestFlexMockShoulds < Test::Unit::TestCase
     end
   end
 
+  def test_multiple_and_raise_clauses_will_be_done_sequentially
+    FlexMock.use do |m|
+      m.should_receive(:failure).
+        and_raise(RuntimeError, "ONE").
+        and_raise(RuntimeError, "TWO")
+      ex = assert_raise RuntimeError do m.failure end
+      assert_equal "ONE", ex.message
+      ex = assert_raise RuntimeError do m.failure end
+      assert_equal "TWO", ex.message
+    end
+  end
+
+  def test_and_throw_will_throw_a_symbol
+    FlexMock.use do |m|
+      m.should_receive(:msg).and_throw(:sym)
+      value = catch(:sym) do
+        m.msg
+        fail "Should not reach this line"
+      end
+      assert_nil value
+    end
+  end
+
+  def test_and_throw_with_expression_will_throw
+    FlexMock.use do |m|
+      m.should_receive(:msg).and_throw(:sym, :return_value)
+      value = catch(:sym) do
+        m.msg
+        fail "Should not reach this line"
+      end
+      assert_equal :return_value, value
+    end
+  end
+
+  def test_throws_is_an_alias_for_and_throw
+    FlexMock.use do |m|
+      m.should_receive(:msg).throws(:sym, :return_value)
+      value = catch(:sym) do
+        m.msg
+        fail "Should not reach this line"
+      end
+      assert_equal :return_value, value
+    end
+  end
+
+  def test_multiple_throws_will_be_done_sequentially
+    FlexMock.use do |m|
+      m.should_receive(:toss).
+        and_throw(:sym, "ONE").
+        and_throw(:sym, "TWO")
+      value = catch(:sym) do m.toss end
+      assert_equal "ONE", value
+      value = catch(:sym) do m.toss end
+      assert_equal "TWO", value
+    end
+  end
+
   def test_multiple_expectations
     FlexMock.use do |m|
       m.should_receive(:hi).with(1).returns(10)
@@ -135,7 +293,7 @@ class TestFlexMockShoulds < Test::Unit::TestCase
     end
   end
 
-  def test__with_no_args_but_with_args
+  def test_with_no_args_but_with_args
     ex = assert_failure(NO_MATCH_ERROR_MESSAGE) do
       FlexMock.use do |m|
         m.should_receive(:hi).with_no_args
@@ -480,7 +638,7 @@ class TestFlexMockShoulds < Test::Unit::TestCase
     assert_match(/hi\(2\)/, ex.message)
   end
 
-  def test_ordered_calls_in_order
+  def test_ordered_calls_in_order_will_pass
     FlexMock.use 'm' do |m|
       m.should_receive(:hi).ordered
       m.should_receive(:lo).ordered
@@ -490,7 +648,7 @@ class TestFlexMockShoulds < Test::Unit::TestCase
     end
   end
 
-  def test_ordered_calls_out_of_order
+  def test_ordered_calls_out_of_order_will_fail
     ex = assert_failure(OUT_OF_ORDER_ERROR_MESSAGE) do
       FlexMock.use 'm' do |m|
         m.should_receive(:hi).ordered
@@ -502,7 +660,7 @@ class TestFlexMockShoulds < Test::Unit::TestCase
     end
   end
 
-  def test_order_calls_with_different_arg_lists_and_in_order
+  def test_order_calls_with_different_arg_lists_and_in_order_will_pass
     FlexMock.use 'm' do |m|
       m.should_receive(:hi).with("one").ordered
       m.should_receive(:hi).with("two").ordered
@@ -512,7 +670,7 @@ class TestFlexMockShoulds < Test::Unit::TestCase
     end
   end
 
-  def test_order_calls_with_different_arg_lists_and_out_of_order
+  def test_order_calls_with_different_arg_lists_and_out_of_order_will_fail
     ex = assert_failure(OUT_OF_ORDER_ERROR_MESSAGE) do
       FlexMock.use 'm' do |m|
         m.should_receive(:hi).with("one").ordered
@@ -538,7 +696,7 @@ class TestFlexMockShoulds < Test::Unit::TestCase
     end
   end
 
-  def test_ordered_with_multiple_calls_is_ok
+  def test_ordered_with_multiple_calls_will_pass
     FlexMock.use 'm' do |m|
       m.should_receive(:hi).ordered
       m.should_receive(:lo).ordered
@@ -628,14 +786,43 @@ class TestFlexMockShoulds < Test::Unit::TestCase
       m.foo  
     end  
   end
+
+  def test_ordering_between_mocks_is_not_normally_defined
+    FlexMock.use("x", "y") do |x, y|
+      x.should_receive(:one).ordered
+      y.should_receive(:two).ordered
+
+      assert_nothing_raised do
+        y.two
+        x.one
+      end
+    end
+  end
   
+  def test_ordering_between_mocks_is_honored_for_global_ordering
+    ex = assert_failure(OUT_OF_ORDER_ERROR_MESSAGE) do 
+      FlexMock.use("x", "y") do |x, y|
+        x.should_receive(:one).globally.ordered
+        y.should_receive(:two).globally.ordered
+        
+        y.two
+        x.one
+      end
+    end
+  end
+
   def test_expectation_formating
-    exp = FlexMock.new("m").should_receive(:f).with(1,"two", /^3$/).and_return(0).at_least.once
+    mock = flexmock("m")
+    exp = mock.should_receive(:f).with(1,"two", /^3$/).
+      and_return(0).at_least.once
+
+    mock.f(1, "two", 3)
     assert_equal 'f(1, "two", /^3$/)', exp.to_s
   end
 
   def test_multi_expectation_formatting
-    exp = FlexMock.new.should_receive(:f, :g).with(1)
+    mock = flexmock("mock")
+    exp = mock.should_receive(:f, :g).with(1)
     assert_equal "[f(1), g(1)]", exp.to_s
   end
 
@@ -659,40 +846,25 @@ class TestFlexMockShoulds < Test::Unit::TestCase
   end
 
   def test_global_methods_can_be_mocked
-    m = FlexMock.new("m")
+    m = flexmock("m")
     m.should_receive(:mock_top_level_function).and_return(:mock)
     assert_equal :mock, m.mock_top_level_function
   end
 
   def test_kernel_methods_can_be_mocked
-    m = FlexMock.new("m")
+    m = flexmock("m")
     m.should_receive(:mock_kernel_function).and_return(:mock)
     assert_equal :mock, m.mock_kernel_function
   end
 
   def test_undefing_kernel_methods_dont_effect_other_mocks
-    m = FlexMock.new("m")
-    m2 = FlexMock.new("m2")
+    m = flexmock("m")
+    m2 = flexmock("m2")
     m.should_receive(:mock_kernel_function).and_return(:mock)
     assert_equal :mock, m.mock_kernel_function
     assert_equal :mkf, m2.mock_kernel_function
   end
 
-  # Assertion helper used to assert validation failure.  If a 
-  # message is given, then the error message should match the 
-  # expected error message.
-  def assert_failure(message=nil)
-    ex = assert_raises(Test::Unit::AssertionFailedError) { yield }
-    if message
-      case message
-      when Regexp
-        assert_match message, ex.message
-      when String
-        assert ex.message.index(message), "Error message '#{ex.message}' should contain '#{message}'"
-      end
-    end
-    ex
-  end
 end
 
 class TestFlexMockShouldsWithInclude < Test::Unit::TestCase