flexmock 0.6.4 → 0.7.0

data/test/redirect_error.rb

@@ -0,0 +1,16 @@
+require 'stringio'
+
+class FlexMock
+  module RedirectError
+    def redirect_error
+      require 'stringio'
+      old_err = $stderr
+      $stderr = StringIO.new
+      yield
+      $stderr.string
+    ensure
+      $stderr = old_err
+    end
+    private :redirect_error
+  end
+end

data/test/rspec_integration/integration_spec.rb

@@ -33,4 +33,10 @@ context "FlexMock in a RSpec example" do
   specify "Should show an example failure" do
     1.should == 2
   end
+
+  specify "Should show how mocks are displayed in error messages" do
+    m = flexmock("x")
+    m.should == 2
+  end
+
 end

data/test/test_demeter_mocking.rb

@@ -0,0 +1,129 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'flexmock'
+require 'test/asserts'
+
+class TestDemeterMocking < Test::Unit::TestCase
+  include FlexMock::TestCase
+  include FlexMock::FailureAssertion
+
+  def test_demeter_mocking
+    m = flexmock("A")
+    m.should_receive("children.first").and_return(:first)
+    assert_kind_of FlexMock, m
+    assert_kind_of FlexMock, m.children
+    assert_equal :first, m.children.first
+  end
+
+  def test_multiple_demeter_mocks_on_same_branch_is_ok
+    m = flexmock("A")
+    m.should_receive("child.x.y.z.first").and_return(:first)
+    m.should_receive("child.x.y.z.last").and_return(:last)
+    assert_equal :first, m.child.x.y.z.first
+    assert_equal :last, m.child.x.y.z.last
+  end
+
+  def test_multi_level_deep_demeter_violation
+    a = flexmock("a")
+    a.should_receive("b.c.d.e.f.g.h.i.j.k").and_return(:xyzzy)
+    assert_equal :xyzzy, a.b.c.d.e.f.g.h.i.j.k
+  end
+
+  def test_final_method_can_have_multiple_expecations
+    a = flexmock("a")
+    a.should_receive("b.c.d.last").with(1).and_return(:one).once
+    a.should_receive("b.c.d.last").with(2).and_return(:two).once
+    assert_equal :one, a.b.c.d.last(1)
+    assert_equal :two, a.b.c.d.last(2)
+  end
+
+  def test_conflicting_mock_declarations_raises_an_error
+    m = flexmock("A")
+    ex = assert_raise(FlexMock::UsageError) do
+      m.should_receive("child").and_return(:xyzzy)
+      m.should_receive("child.other").and_return(:other)
+      m.child.other
+    end
+    assert_match(/conflicting/i, ex.message)
+    assert_match(/mock\s+declaration/i, ex.message)
+    assert_match(/child/i, ex.message)
+  end
+
+  def test_conflicting_mock_declarations_in_reverse_order_does_not_raise_error
+    # Not all conflicting definitions can be detected.
+    m = flexmock("A")
+    assert_failure() do
+      m.should_receive("child.other").and_return(:other)
+      m.should_receive("child").and_return(:xyzzy)
+      assert_equal :xyzzy, m.child.other
+    end
+  end
+
+  def test_preestablishing_existing_mock_is_ok
+    engine = flexmock("engine")
+    car = flexmock("A")
+    car.should_receive(:engine).and_return(engine)
+    car.should_receive("engine.cylinder").and_return(:cyl)
+    assert_equal :cyl, car.engine.cylinder
+  end
+
+  def test_quick_defs_can_use_demeter_mocking
+    a = flexmock("a")
+    a.should_receive("b.c.d.x").and_return(:x)
+    a.should_receive("b.c.d.y").and_return(:y)
+    a.should_receive("b.c.d.z").and_return(:z)
+    assert_equal :x, a.b.c.d.x
+    assert_equal :y, a.b.c.d.y
+    assert_equal :z, a.b.c.d.z
+  end
+
+  def test_quick_defs_can_use_demeter_mocking_two
+    a = flexmock("a", "b.c.d.xx" => :x, "b.c.d.yy" => :y, "b.c.d.zz" => :z)
+    assert_equal :x, a.b.c.d.xx
+    assert_equal :y, a.b.c.d.yy
+    assert_equal :z, a.b.c.d.zz
+  end
+
+  def test_errors_on_ill_formed_method_names
+    m = flexmock("a")
+    [
+      'a(2)', '0a', 'a-b', 'a b', ' ', 'a ', ' b', 'a!b', "a?b", 'a=b'
+    ].each do |method|
+      assert_raise FlexMock::UsageError do m.should_receive(method) end
+    end
+  end
+
+  def test_no_errors_on_well_formed_method_names
+    m = flexmock("a")
+    [
+      'a', 'a?', 'a!', 'a=', 'z0', 'save!'
+    ].each do |method|
+      assert_nothing_raised do m.should_receive(method) end
+    end
+  end
+
+  def test_readme_example_1
+    cog = flexmock("cog")
+    cog.should_receive(:turn).once.and_return(:ok).mock
+    joint = flexmock("gear", :cog => cog)
+    axle = flexmock("axle", :universal_joint => joint)
+    chassis = flexmock("chassis", :axle => axle)
+    car = flexmock("car", :chassis => chassis)
+    assert_equal :ok, car.chassis.axle.universal_joint.cog.turn
+  end
+
+  def test_readme_example_2
+    car = flexmock("car")
+    car.should_receive("chassis.axle.universal_joint.cog.turn" => :ok).once
+    assert_equal :ok, car.chassis.axle.universal_joint.cog.turn
+  end
+
+  def test_readme_example_3
+    car = flexmock("car")
+    car.should_receive("chassis.axle.universal_joint.cog.turn").once.
+      and_return(:ok)
+    assert_equal :ok, car.chassis.axle.universal_joint.cog.turn
+  end
+
+end

data/test/{test_mock.rb → test_deprecated_methods.rb}

@@ -11,34 +11,43 @@
 
 require 'test/unit'
 require 'flexmock'
+require 'flexmock/deprecated_methods'
+require 'test/redirect_error'
 
 class TestFlexMock < Test::Unit::TestCase
+  include FlexMock::TestCase
+  include FlexMock::RedirectError
+
+  def s(&block)
+    redirect_error(&block)
+  end
+
   def setup
-    @mock = FlexMock.new
+    @mock = flexmock('mock')
   end
 
   def test_handle
     args = nil
-    @mock.mock_handle(:hi) { |a, b| args = [a,b] }
+    s { @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)
+    s { @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 }
+    s { @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 }
+    s { @mock.mock_handle(:blip) { 10 } }
     assert_equal 10, @mock.blip
   end
 
@@ -57,19 +66,19 @@ class TestFlexMock < Test::Unit::TestCase
   end
 
   def test_good_counts
-    @mock.mock_handle(:blip, 3)
+    s { @mock.mock_handle(:blip, 3) }
     @mock.blip
     @mock.blip
     @mock.blip
-    @mock.mock_verify
+    @mock.flexmock_verify
   end
 
   def test_bad_counts
-    @mock.mock_handle(:blip, 3)
+    s { @mock.mock_handle(:blip, 3) }
     @mock.blip
     @mock.blip
     begin
-      @mock.mock_verify
+      @mock.flexmock_verify
     rescue Test::Unit::AssertionFailedError => err
     end
     assert_not_nil err
@@ -77,7 +86,7 @@ class TestFlexMock < Test::Unit::TestCase
 
   def test_undetermined_counts
     FlexMock.use('fs') { |m|
-      m.mock_handle(:blip)
+      s { m.mock_handle(:blip) }
       m.blip
       m.blip
       m.blip
@@ -87,7 +96,7 @@ class TestFlexMock < Test::Unit::TestCase
   def test_zero_counts
     assert_raises(Test::Unit::AssertionFailedError) do
       FlexMock.use { |m|
-        m.mock_handle(:blip, 0)
+        s { m.mock_handle(:blip, 0) }
         m.blip
       }
     end
@@ -96,7 +105,7 @@ class TestFlexMock < Test::Unit::TestCase
   def test_file_io_with_use
     file = FlexMock.use do |m|
       filedata = ["line 1", "line 2"]
-      m.mock_handle(:gets, 3) { filedata.shift }
+      s { m.mock_handle(:gets, 3) { filedata.shift } }
       assert_equal 2, count_lines(m)
     end
   end
@@ -112,7 +121,7 @@ class TestFlexMock < Test::Unit::TestCase
   def test_use
     assert_raises(Test::Unit::AssertionFailedError) {
       FlexMock.use do |m|
-	m.mock_handle(:blip, 2)
+	s { m.mock_handle(:blip, 2) }
 	m.blip
       end
     }
@@ -121,7 +130,7 @@ class TestFlexMock < Test::Unit::TestCase
   def test_failures_during_use
     ex = assert_raises(NameError) {
       FlexMock.use do |m|
-	m.mock_handle(:blip, 2)
+	s { m.mock_handle(:blip, 2) }
 	xyz
       end
     }
@@ -130,7 +139,7 @@ class TestFlexMock < Test::Unit::TestCase
 
   def test_sequential_values
     values = [1,4,9,16]
-    @mock.mock_handle(:get) { values.shift }
+    s { @mock.mock_handle(:get) { values.shift } }
     assert_equal 1, @mock.get
     assert_equal 4, @mock.get
     assert_equal 9, @mock.get
@@ -142,7 +151,7 @@ class TestFlexMock < Test::Unit::TestCase
   end
 
   def test_respond_to_returns_true_for_explicit_methods
-    @mock.mock_handle(:xyz)
+    s { @mock.mock_handle(:xyz) }
     assert(@mock.respond_to?(:xyz), "should respond to test")
   end
 
@@ -164,7 +173,7 @@ class TestFlexMock < Test::Unit::TestCase
 
   def test_method_returns_callable_proc
     got_it = false
-    @mock.mock_handle(:xyzzy) { got_it = true }
+    s { @mock.mock_handle(:xyzzy) { got_it = true } }
     method_proc = @mock.method(:xyzzy)
     assert_not_nil method_proc
     method_proc.call
@@ -178,3 +187,41 @@ class TestFlexMock < Test::Unit::TestCase
     method_proc.call
   end
 end
+
+class TestDeprecatedOrderingMethods < Test::Unit::TestCase
+  include FlexMock::TestCase
+  include FlexMock::RedirectError
+
+  def test_deprecated_ordering_methods
+    flexmock(:x).should_receive(:msg).globally.ordered(:testgroup)
+    assert_equal({ :testgroup => 1 }, flexmock_groups)
+    message = redirect_error do
+      assert_equal({ :testgroup => 1 }, mock_groups)
+    end
+    assert_match(/deprecated/i, message)
+    assert_match(/\bmock_groups/, message)
+    assert_match(/\bflexmock_groups/, message)
+  end
+end
+
+class TestAnyInstance < Test::Unit::TestCase
+  include FlexMock::TestCase
+  include FlexMock::RedirectError
+
+  class Dog
+    def bark
+      :woof
+    end
+  end
+
+  def test_any_instance_still_works_for_backwards_compatibility
+    message = redirect_error do
+      flexstub(Dog).any_instance do |obj|
+        obj.should_receive(:bark).and_return(:whimper)
+        assert_match(/deprecated/, message)
+      end
+    end
+    m = Dog.new
+    assert_equal :whimper,  m.bark   
+  end
+end  

data/test/test_example.rb

@@ -21,14 +21,15 @@ class TemperatureSampler
     total = (0...3).collect { @sensor.read_temperature }.inject { |i, s| i + s }
     total / 3.0
   end
-    
 end
 
 class TestTemperatureSampler < Test::Unit::TestCase
+  include FlexMock::TestCase
+
   def test_tempurature_sampler
     readings = [10, 12, 14]
-    mock_sensor = FlexMock.new
-    mock_sensor.mock_handle(:read_temperature) { readings.shift }
+    mock_sensor = flexmock("sensor")
+    mock_sensor.should_receive(:read_temperature).and_return { readings.shift }
     sampler = TemperatureSampler.new(mock_sensor)
     assert_equal 12, sampler.average_temp
   end

data/test/test_extended_should_receive.rb

@@ -36,7 +36,7 @@ module ExtendedShouldReceiveTests
   def test_count_contraints_apply_to_all_expectations
     @mock.should_receive(:foo, :bar => :baz).once
     @obj.foo
-    assert_raise(Test::Unit::AssertionFailedError) { @mock.mock_verify }
+    assert_raise(Test::Unit::AssertionFailedError) { @mock.flexmock_verify }
   end
   
   def test_multiple_should_receives_are_allowed

data/test/test_flexmodel.rb

@@ -5,17 +5,33 @@ require 'test/unit'
 class DummyModel
 end
 
+class ChildModel < DummyModel
+end
+
 ######################################################################
 class TestFlexModel < Test::Unit::TestCase
   include FlexMock::TestCase
 
   def test_initial_conditions
     model = flexmock(:model, DummyModel)
-    assert_match(/^DummyModel_\d+/, model.mock_name)
+    assert_match(/^DummyModel_\d+/, model.flexmock_name)
     assert_equal model.id.to_s, model.to_params
     assert ! model.new_record?
     assert model.is_a?(DummyModel)
+    # TODO: Make these work!!!
     assert_equal DummyModel, model.class
+    assert model.instance_of?(DummyModel)
+    assert model.kind_of?(DummyModel)
+  end
+
+  def test_classifying_mock_models
+    model = flexmock(:model, ChildModel)
+
+    assert model.kind_of?(ChildModel)
+    assert model.instance_of?(ChildModel)
+
+    assert model.kind_of?(DummyModel)
+    assert ! model.instance_of?(DummyModel)
   end
 
   def test_mock_models_have_different_ids

data/test/test_naming.rb

@@ -13,13 +13,15 @@ require 'test/unit'
 require 'flexmock'
 
 class TestNaming < Test::Unit::TestCase
+  include FlexMock::TestCase
+  
   def test_name
-    m = FlexMock.new("m")
-    assert_equal "m", m.mock_name
+    m = flexmock("m")
+    assert_equal "m", m.flexmock_name
   end
 
   def test_name_in_no_handler_found_error
-    m = FlexMock.new("mmm")
+    m = flexmock("mmm")
     ex = assert_raises(Test::Unit::AssertionFailedError) {
       m.should_receive(:xx).with(1)
       m.xx(2)
@@ -28,24 +30,57 @@ class TestNaming < Test::Unit::TestCase
   end
 
   def test_name_in_received_count_error
-    m = FlexMock.new("mmm")
+    m = flexmock("mmm")
     ex = assert_raises(Test::Unit::AssertionFailedError) {
       m.should_receive(:xx).once
-      m.mock_verify
+      m.flexmock_verify
     }
    assert_match(/'mmm'/, ex.message)
   end
 
   def test_naming_with_use
     FlexMock.use("blah") do |m|
-      assert_equal "blah", m.mock_name
+      assert_equal "blah", m.flexmock_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
+      assert_equal "blah", a.flexmock_name
+      assert_equal "yuk",  b.flexmock_name
     end
   end
+
+  def test_inspect_returns_reasonable_name
+    FlexMock.use("XYZZY") do |m|
+      assert_equal "XYZZY", m.flexmock_name
+      assert_equal "<FlexMock:XYZZY>", m.inspect
+    end
+  end
+
+  def test_mock_can_override_inspect
+    FlexMock.use("XYZZY") do |m|
+      m.should_receive(:inspect).with_no_args.and_return("MOCK-INSPECT")
+      assert_equal "MOCK-INSPECT", m.inspect
+    end
+  end
+
+  class Dummy
+    def inspect
+      "DUMMY-INSPECT"
+    end
+  end
+
+  def test_partial_mocks_use_original_inspect
+    dummy = Dummy.new
+    flexmock(dummy).should_receive(:msg)
+    assert_equal "DUMMY-INSPECT", dummy.inspect
+  end
+
+  def test_partial_mocks_can_override_inspect
+    dummy = Dummy.new
+    flexmock(dummy).should_receive(:inspect).and_return("MOCK-INSPECT")
+    assert_equal "MOCK-INSPECT", dummy.inspect
+  end
 end
+