flexmock 0.7.1 → 0.8.0

data/test/test_examples_from_readme.rb

@@ -0,0 +1,158 @@
+#!/usr/bin/env ruby
+
+#---
+# Copyright 2003, 2004, 2005, 2006, 2007 by Jim Weirich (jim@weirichhouse.org).
+# 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'
+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
+  include FlexMock::TestCase
+
+  def test_tempurature_sampler
+    readings = [10, 12, 14]
+    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
+end
+
+class TestExamplesFromReadme < Test::Unit::TestCase
+  include FlexMock::TestCase
+
+  def test_simple_return_values
+    m = flexmock(:pi => 3.1416, :e => 2.71)
+    assert_equal 3.1416, m.pi
+    assert_equal 2.71, m.e
+  end
+
+  def test_returning_an_undefined_value
+    m = flexmock("mock")
+    m.should_receive(:foo).and_return_undefined
+    m.foo.bar.baz
+  end
+  
+  def test_db
+    db = flexmock('db')
+    db.should_receive(:query).and_return([1,2,3])
+    db.should_receive(:update).with(5).and_return(nil).once
+    # test code here
+    assert_equal [1, 2, 3], db.query
+    db.update(5)
+  end
+
+  def test_query_and_update
+    db = flexmock('db')
+    db.should_receive(:query).and_return([1,2,3]).ordered
+    db.should_receive(:update).and_return(nil).ordered
+    # test code here
+    assert_equal [1,2,3], db.query
+    assert_nil db.update
+  end
+
+  def test_ordered_queries
+    db = flexmock('db')
+    db.should_receive(:startup).once.ordered
+    db.should_receive(:query).with("GOOG").and_return(12.3).
+      once.ordered(:queries)
+    db.should_receive(:query).with("APPL").and_return(10.0).
+      once.ordered(:queries)
+    db.should_receive(:query).with(/^....$/).and_return(3.3).
+      at_least.once.ordered(:queries)
+    db.should_receive(:finish).once.ordered
+    # test code here
+    db.startup
+    assert_equal 3.3,  db.query("WXYZ")
+    assert_equal 10.0, db.query("APPL")
+    assert_equal 12.3, db.query("GOOG")
+    db.finish
+  end
+  
+  def test_ordered_queries_in_record_mode
+    db = flexmock('db')
+    db.should_expect do |rec|
+      rec.startup.once.ordered
+      rec.query("GOOG") { 12.3 }.once.ordered(:queries)
+      rec.query("APPL") { 10.0 }.once.ordered(:queries)
+      rec.query(/^....$/) { 3.3 }.at_least.once.ordered(:queries)
+      rec.finish.once.ordered
+    end
+    # test code here using +db+.
+    db.startup
+    assert_equal 10.0, db.query("APPL")
+    assert_equal 12.3, db.query("GOOG")
+    assert_equal 3.3,  db.query("WXYZ")
+    db.finish
+  end
+
+  def test_build_xml
+    builder = flexmock('builder')
+    builder.should_expect do |rec|
+      rec.should_be_strict
+      known_good_way_to_build_xml(rec)  # record the messages
+    end
+    new_way_to_build_xml(builder)       # compare to new way
+  end
+
+  def known_good_way_to_build_xml(rec)
+    rec.one
+    rec.two
+  end
+
+  def new_way_to_build_xml(rec)
+    [:one, :two].each do |sym| rec.send(sym) end
+  end
+
+  def test_multiple_gets
+    file = flexmock('file')
+    file.should_receive(:gets).with_no_args.
+      and_return("line 1\n", "line 2\n")
+    # test code here
+    assert_equal "line 1\n", file.gets
+    assert_equal "line 2\n", file.gets
+  end
+
+  def test_an_important_message
+    m = flexmock('m')
+    m.should_receive(:an_important_message).and_return(1).once
+    m.should_ignore_missing
+    # test code here
+    m.an_important_message
+    m.unknown_message.bar.baz
+  end
+
+  class QuoteService
+  end
+  class Portfolio
+    def value
+      QuoteService.new.quote
+    end
+  end
+  
+  def test_portfolio_value
+    flexmock(QuoteService).new_instances do |m|
+      m.should_receive(:quote).and_return(100)
+    end
+    port = Portfolio.new
+    value = port.value     # Portfolio calls QuoteService.quote
+    assert_equal 100, value
+  end
+end

data/test/test_partial_mock.rb

@@ -25,6 +25,18 @@ class TestStubbing < Test::Unit::TestCase
     end
   end
 
+  class DogPlus < Dog
+    def should_receive
+      :dog_should
+    end
+    def new_instances
+      :dog_new
+    end
+    def by_default
+      :dog_by_default
+    end
+  end
+
   def test_stub_command_add_behavior_to_arbitrary_objects
     obj = Object.new
     flexmock(obj).should_receive(:hi).once.and_return(:stub_hi)
@@ -289,6 +301,13 @@ class TestStubbing < Test::Unit::TestCase
     assert_equal :mocked, dog.bark
   end
 
+  def test_should_receive_does_not_override_preexisting_def
+    dog = flexmock(DogPlus.new)
+    assert_equal :dog_should,     dog.should_receive
+    assert_equal :dog_new,        dog.new_instances
+    assert_equal :dog_by_default, dog.by_default
+  end
+
   class Liar
     def respond_to?(method_name)
       sym = method_name.to_sym
@@ -311,5 +330,28 @@ class TestStubbing < Test::Unit::TestCase
     flexmock(liar, :not_defined => :xyzzy)
     assert_equal :xyzzy, liar.not_defined
   end
+
+  # The following test was suggested by Pat Maddox for the RSpec
+  # mocks.  Evidently the (poorly implemented) == method caused issues
+  # with RSpec Mock's internals.  I'm just double checking for any
+  # similar issues in FlexMock as well.
+
+  class ValueObject
+    attr_reader :val
+
+    def initialize(val)
+      @val = val
+    end
+
+    def ==(other)
+      @val == other.val
+    end
+  end
+
+  def test_partial_mocks_in_the_presense_of_equal_definition
+    flexmock("existing obj", :foo => :foo)
+    obj = ValueObject.new(:bar)
+    flexmock(obj, :some_method => :some_method)
+  end
   
 end

data/test/test_rails_view_stub.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'flexmock/rails/view_mocking'
+
+######################################################################
+class TestRailsViewStub < Test::Unit::TestCase
+  include FlexMock::TestCase
+
+  def setup
+    @controller_class = flexmock("controller class")
+    @controller = flexmock("controller", :class => @controller_class)
+  end
+
+  def test_view_mocks_as_stub
+    should_render_view
+    render "controller/new.rthml"
+  end
+
+  def test_fails_if_no_render
+    should_render_view
+    assert_raise(Test::Unit::AssertionFailedError) do
+      flexmock_verify
+    end
+  end
+
+  def test_view_mocks_with_expectation
+    should_render_view("new")
+    render "controller/new"
+  end
+
+  def test_view_mocks_with_expectation_fails_with_different_template
+    should_render_view("new")
+    render "controller/edit"
+    assert_raise(Test::Unit::AssertionFailedError) do
+      flexmock_verify
+    end
+  end
+
+  def test_view_mocks_with_expectation_wand_multiple_templates
+    should_render_view("new")
+    render "controller/edit", "controller/new", "controller/show"
+  end
+
+  private
+
+  def render(*names)
+    vc = @controller.class.view_class
+    v = vc.new
+    v.assigns(:x => :y)
+    v.render_file
+    v.first_render
+    names.each do |name|
+      v.file_exists?(name)
+    end
+  end
+end

data/test/test_samples.rb

@@ -39,3 +39,247 @@ class TestSamples < Test::Unit::TestCase
   end
 end
 
+
+class TestUndefined < Test::Unit::TestCase
+  include FlexMock::TestCase
+
+  def test_undefined_values
+    m = flexmock("mock")
+    m.should_receive(:divide_by).with(0).
+      and_return_undefined
+    assert_equal FlexMock.undefined, m.divide_by(0)
+  end
+end
+
+
+class TestSimple < Test::Unit::TestCase
+  include FlexMock::TestCase
+
+  def test_simple_mock
+    m = flexmock(:pi => 3.1416, :e => 2.71)
+    assert_equal 3.1416, m.pi
+    assert_equal 2.71, m.e
+  end
+end
+
+class TestDog < Test::Unit::TestCase
+  include FlexMock::TestCase
+  
+  def test_dog_wags
+    tail_mock = flexmock(:wag => :happy)
+    assert_equal :happy, tail_mock.wag
+  end
+end
+
+class Woofer
+end
+
+class Dog
+  def initialize
+    @woofer = Woofer.new
+  end
+  def bark
+    @woofer.woof
+  end
+  def wag
+    :happy
+  end
+end
+
+class TestDogBarking < Test::Unit::TestCase
+  include FlexMock::TestCase
+  
+  # Setup the tests by mocking the +new+ method of 
+  # Woofer and return a mock woofer.
+  def setup
+    @dog = Dog.new
+    flexmock(@dog, :bark => :grrr)
+  end
+  
+  def test_dog
+    assert_equal :grrr, @dog.bark   # Mocked Method
+    assert_equal :happy, @dog.wag    # Normal Method
+  end
+end
+
+class TestDogBarkingWithNewInstances < Test::Unit::TestCase
+  include FlexMock::TestCase
+  
+  # Setup the tests by mocking Woofer to always
+  # return partial mocks.
+  def setup
+    flexmock(Woofer).new_instances.should_receive(:woof => :grrr)
+  end
+  
+  def test_dog
+    assert_equal :grrr, Dog.new.bark  # All dog objects
+    assert_equal :grrr, Dog.new.bark  # are mocked.
+  end
+end
+
+class TestDefaults < Test::Unit::TestCase
+  include FlexMock::TestCase
+
+  def setup
+    @mock_dog = flexmock("Fido")
+    @mock_dog.should_receive(:tail => :a_tail, :bark => "woof").by_default
+  end
+  
+  def test_something_where_bark_must_be_called_once
+    @mock_dog.should_receive(:bark => "bow wow").once
+
+    assert_equal "bow wow", @mock_dog.bark
+    assert_equal :a_tail, @mock_dog.tail
+  end 
+end
+
+class TestDemeter < Test::Unit::TestCase
+  include FlexMock::TestCase
+  def test_manual_mocking
+    # Manually mocking a Law of Demeter violation
+    cog = flexmock("cog")
+    cog.should_receive(:turn).once.and_return(:ok)
+    joint = flexmock("gear", :cog => cog)
+    axle = flexmock("axle", :universal_joint => joint)
+    chassis = flexmock("chassis", :axle => axle)
+    car = flexmock("car", :chassis => chassis)
+
+    # test code
+    assert_equal :ok, car.chassis.axle.universal_joint.cog.turn
+  end
+
+  def test_demeter
+    car = flexmock("car")
+    car.should_receive( "chassis.axle.universal_joint.cog.turn" => :ok).once
+
+    # Test code
+    assert_equal :ok, car.chassis.axle.universal_joint.cog.turn
+  end
+
+end
+
+class TestDb < Test::Unit::TestCase
+  include FlexMock::TestCase
+
+  def test_db
+    db = flexmock('db')
+    db.should_receive(:query).and_return([1,2,3])
+    db.should_receive(:update).with(5).and_return(nil).once
+
+    # test code
+    assert_nil db.update(5)
+  end
+end
+
+
+class TestDb < Test::Unit::TestCase
+  include FlexMock::TestCase
+
+  def test_query_and_update
+    db = flexmock('db')
+    db.should_receive(:query).and_return([1,2,3]).ordered
+    db.should_receive(:update).and_return(nil).ordered
+    # test code here
+    assert_raises(Test::Unit::AssertionFailedError) do
+      db.update
+      db.query
+    end
+  end
+
+  def test_ordered_queries
+    db = flexmock('db')
+    db.should_receive(:startup).once.ordered
+    db.should_receive(:query).with("CPWR").and_return(12.3).
+      once.ordered(:queries)
+    db.should_receive(:query).with("MSFT").and_return(10.0).
+      once.ordered(:queries)
+    db.should_receive(:query).with(/^....$/).and_return(3.3).
+      at_least.once.ordered(:queries)
+    db.should_receive(:finish).once.ordered
+    # test code here
+    db.startup
+    db.query("CPWR")
+    db.query("MSFT")
+    db.query("asdf")
+    db.finish
+  end
+
+  def test_ordered_queries_in_record_mode
+    db = flexmock('db')
+    db.should_expect do |rec|
+      rec.startup.once.ordered
+      rec.query("CPWR") { 12.3 }.once.ordered(:queries)
+      rec.query("MSFT") { 10.0 }.once.ordered(:queries)
+      rec.query(/^....$/) { 3.3 }.at_least.once.ordered(:queries)
+      rec.finish.once.ordered
+    end
+    # test code here using +db+.
+    db.startup
+    db.query("CPWR")
+    db.query("MSFT")
+    db.query("asdf")
+    db.finish
+  end
+  
+  def known_good_way_to_build_xml(builder)
+    builder.html
+  end
+
+  def new_way_to_build_xml(builder)
+    known_good_way_to_build_xml(builder)
+  end
+
+  def test_build_xml
+    builder = flexmock('builder')
+    builder.should_expect do |rec|
+      rec.should_be_strict
+      known_good_way_to_build_xml(rec)  # record the messages
+    end
+    new_way_to_build_xml(builder)       # compare to new way
+  end
+  
+end
+
+class TestMoreSamples < Test::Unit::TestCase
+  include FlexMock::TestCase
+
+  def test_multiple_gets
+    file = flexmock('file')
+    file.should_receive(:gets).with_no_args.
+      and_return("line 1\n", "line 2\n")
+    # test code here
+    assert_equal "line 1\n", file.gets
+    assert_equal "line 2\n", file.gets
+  end
+
+  def test_an_important_message
+    m = flexmock('m')
+    m.should_receive(:an_important_message).and_return(1).once
+    m.should_ignore_missing
+    # test code here
+    assert_equal 1, m.an_important_message
+    assert_equal FlexMock.undefined, m.other
+  end
+
+  class QuoteService
+  end
+
+  class Portfolio
+    def initialize
+      @quote_service = QuoteService.new
+    end
+    def value
+      @quote_service.quote
+    end
+  end
+
+  def test_portfolio_value
+    flexmock(QuoteService).new_instances do |m|
+      m.should_receive(:quote).and_return(100)
+    end
+    port = Portfolio.new
+    value = port.value     # Portfolio calls QuoteService.quote
+    assert_equal 100, value
+  end
+
+end

data/test/test_should_ignore_missing.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+
+#---
+# Copyright 2003, 2004, 2005, 2006, 2007 by Jim Weirich (jim@weirichhouse.org).
+# 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'
+require 'flexmock'
+require 'test/asserts'
+
+class TestShouldIgnoreMissing < Test::Unit::TestCase
+  include FlexMock::TestCase
+
+  def setup
+    @mock = flexmock("mock")
+  end
+  
+  def test_mocks_do_not_respond_to_undefined_methods
+    assert !@mock.respond_to?(:unknown_foo)
+  end
+
+  def test_mocks_do_respond_to_defined_methods
+    @mock.should_receive(:known_foo => :bar)
+    assert @mock.respond_to?(:known_foo)
+  end
+
+  def test_mocks_do_respond_to_any_method_when_ignoring_missing
+    @mock.should_ignore_missing
+    assert @mock.respond_to?(:unknown_foo)
+  end
+
+  def test_ignored_methods_return_undefined
+    @mock.should_ignore_missing
+    assert_equal FlexMock.undefined, @mock.unknown_foo
+    @mock.unknown_foo.bar.baz.bleep
+  end
+
+  def test_undefined_mocking_with_arguments
+    @mock.should_ignore_missing
+    assert_equal FlexMock.undefined, @mock.xyzzy(1,:two,"three")
+  end
+
+  def test_method_chains_with_undefined_are_self_preserving
+    @mock.should_ignore_missing
+    assert_equal FlexMock.undefined, @mock.a.b.c.d.e.f(1).g.h.i.j
+  end
+
+  def test_method_proc_raises_error_on_unknown
+    assert_raises(NameError) {
+      @mock.method(:unknown_foo)
+    }
+  end
+
+  def test_method_returns_callable_proc
+    @mock.should_receive(:known_foo).once
+    method_proc = @mock.method(:known_foo)
+    assert_not_nil method_proc
+    method_proc.call
+  end
+
+  def test_not_calling_method_proc_will_fail_count_constraints
+    @mock.should_receive(:known_foo).once
+    method_proc = @mock.method(:known_foo)
+    assert_not_nil method_proc
+    assert_raises Test::Unit::AssertionFailedError do
+      flexmock_teardown
+    end
+  end
+
+  def test_method_returns_do_nothing_proc_for_missing_methods
+    @mock.should_ignore_missing
+    method_proc = @mock.method(:plugh)
+    assert_not_nil method_proc
+    assert_equal FlexMock.undefined, method_proc.call
+  end
+end
+