flexmock 1.3.3 → 2.0.0.rc1

data/doc/examples/test_unit_examples_test.rdoc

@@ -1,241 +0,0 @@
-= FlexMock Examples
-    require 'flexmock/test_unit'
-    
-    class TestSimple < Test::Unit::TestCase
-    
-      # Simple stubbing of some methods
-    
-      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 TestUndefined < Test::Unit::TestCase
-    
-      # Create a mock object that returns an undefined object for method calls
-    
-      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 TestDb < Test::Unit::TestCase
-    
-      # Expect multiple queries and a single update
-    
-      # Multiple calls to the query method will be allows, and calls may
-      # have any argument list. Each call to query will return the three
-      # element array [1, 2, 3]. The call to update must have a specific
-      # argument of 5.
-    
-      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
-    
-        db.query
-        db.update(5)
-      end
-    end
-    
-    class TestOrdered < Test::Unit::TestCase
-    
-      # Expect all queries before any updates
-    
-      # All the query message must occur before any of the update
-      # messages.
-    
-      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
-    
-        db.query
-        db.update
-      end
-    end
-    
-    class MoreOrdered < Test::Unit::TestCase
-    
-      # Expect several queries with different parameters
-    
-      # The queries should happen after startup but before finish. The
-      # queries themselves may happen in any order (because they are in
-      # the same order group). The first two queries should happen exactly
-      # once, but the third query (which matches any query call with a
-      # four character parameter) may be called multiple times (but at
-      # least once). Startup and finish must also happen exactly once.
-    
-      # Also note that we use the <code>with</code> method to match
-      # different argument values to figure out what value to return.
-    
-      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
-    
-        db.startup
-        db.query("MSFT")
-        db.query("XYZY")
-        db.query("CPWR")
-        db.finish
-      end
-    end
-    
-    class EvenMoreOrderedTest < Test::Unit::TestCase
-    
-      # Same as above, but using the Record Mode interface
-    
-      # The record mode interface offers much the same features as the
-      # <code>should_receive</code> interface introduced so far, but it
-      # allows the messages to be sent directly to a recording object
-      # rather than be specified indirectly using a symbol.
-    
-    
-      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
-    
-        db.startup
-        db.query("MSFT")
-        db.query("XYZY")
-        db.query("CPWR")
-        db.finish
-      end
-    end
-    
-    class RecordedTest < Test::Unit::TestCase
-    
-      # Using Record Mode to record a known, good algorithm for testing
-    
-      # Record mode is nice when you have a known, good algorithm that can
-      # use a recording mock object to record the steps. Then you compare
-      # the execution of a new algorithm to behavior of the old using the
-      # recorded expectations in the mock. For this you probably want to
-      # put the recorder in _strict_ mode so that the recorded
-      # expectations use exact matching on argument lists, and strict
-      # ordering of the method calls.
-    
-      # <b>Note:</b> This is most useful when there are no queries on the
-      # mock objects, because the query responses cannot be programmed
-      # into the recorder object.
-    
-      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(builder)
-        builder.person
-      end
-    
-      def new_way_to_build_xml(builder)
-        builder.person
-      end
-    
-    end
-    
-    class MultipleReturnValueTest < Test::Unit::TestCase
-    
-      # Expect multiple calls, returning a different value each time
-    
-      # Sometimes you need to return different values for each call to a
-      # mocked method. This example shifts values out of a list for this
-      # effect.
-    
-      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
-    
-        file.gets                   # returns "line 1"
-        file.gets                   # returns "line 2"
-      end
-    end
-    
-    class IgnoreUnimportantMessages < Test::Unit::TestCase
-    
-      # Ignore uninteresting messages
-    
-      # Generally you need to mock only those methods that return an
-      # interesting value or wish to assert were sent in a particular
-      # manner. Use the <code>should_ignore_missing</code> method to turn
-      # on missing method ignoring.
-    
-      def test_an_important_message
-        m = flexmock('m')
-        m.should_receive(:an_important_message).and_return(1).once
-        m.should_ignore_missing
-    
-        # Test Code
-    
-        m.an_important_message
-        m.an_unimportant_message
-      end
-    
-      # When <code>should_ignore_missing</code> is enabled, ignored
-      # missing methods will return an undefined object. Any operation on
-      # the undefined object will return the undefined object.
-    
-    end
-    
-    class PartialMockTest < Test::Unit::TestCase
-    
-      # Mock just one method on an existing object
-    
-      # The Portfolio class calculate the value of a set of stocks by
-      # talking to a quote service via a web service. Since we don't want
-      # to use a real web service in our unit tests, we will mock the
-      # quote service.
-    
-      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
-    
-      class QuoteService
-      end
-    
-      class Portfolio
-        def value
-          qs = QuoteService.new
-          qs.quote
-        end
-      end
-    end

data/test/aliasing_test.rb

@@ -1,66 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'test/test_setup'
-
-# This is an experimental test to see if mock and stub methods can
-# easily be added to a flexmock core. These test are disabled by
-# default, and should be reviewed before something more production
-# oriented is provided.
-
-if ENV['TEST_ALIASES']
-
-  class FlexMock
-    module StubsAndExpects
-      def expects(*args)
-        result = should_receive(*args)
-        result.at_least.once unless result.call_count_constrained?
-        result
-      end
-      def stubs(*args)
-        should_receive(*args)
-      end
-    end
-
-    module MockContainer
-      alias :mock :flexmock
-      alias :stub :flexmock
-    end
-
-    include StubsAndExpects
-
-    class PartialMockProxy
-      include StubsAndExpects
-      MOCK_METHODS << :stubs << :expects
-    end
-  end
-
-  class AliasingTest < Test::Unit::TestCase
-    include FlexMock::TestCase
-
-    def test_mocking
-      m = mock("a cute dog").expects(:pat).twice.and_return(:woof!).mock
-      assert_equal :woof!, m.pat
-      assert_equal :woof!, m.pat
-    end
-
-    def test_once_mocking
-      mock("a cute dog").expects(:pat).and_return(:woof!).mock
-    end
-
-    def test_twice_mocking
-      m = mock("a cute dog").expects(:pat).and_return(:woof!).twice.mock
-      assert_raises(assertion_failed_error) { m.flexmock_verify }
-    end
-
-    def test_stubbing
-      m = stub("a cute dog").expects(:pat).and_return(:woof!).mock
-      assert_equal :woof!, m.pat
-    end
-
-    def test_partial
-      obj = Object.new
-      stub(obj).stubs(:wag).and_return(:tail)
-      assert_equal :tail, obj.wag
-    end
-  end
-end

data/test/assert_spy_called_test.rb

@@ -1,119 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'test/test_setup'
-require 'flexmock/test_unit_assert_spy_called'
-
-class AssertSpyCalledTest < Test::Unit::TestCase
-  include FlexMock::TestCase
-
-  class FooBar
-    def foo
-    end
-    def bar
-    end
-  end
-
-  def setup
-    super
-    @spy = flexmock(:on, FooBar)
-  end
-
-  def spy
-    @spy
-  end
-
-  def test_assert_detects_basic_call
-    spy.foo
-    assert_spy_called spy, :foo
-  end
-
-  def test_assert_detects_basic_call_with_args
-    spy.foo(1,2)
-    assert_spy_called spy, :foo, 1, 2
-  end
-
-  def test_assert_rejects_incorrect_args
-    spy.foo(1,2)
-    assert_fails(/^expected foo\(1, 3\) to be received by <FlexMock:AssertSpyCalledTest::FooBar Mock>/i) do
-      assert_spy_called spy, :foo, 1, 3
-    end
-  end
-
-  def test_assert_detects_multiple_calls
-    spy.foo
-    spy.foo
-    spy.foo
-    assert_spy_called spy, {:times => 3}, :foo
-  end
-
-  def test_assert_rejects_incorrect_type
-    spy.foo
-    spy.foo
-    assert_fails(/^expected foo\(\) to be received by <FlexMock:AssertSpyCalledTest::FooBar Mock> 3 times/i) do
-      assert_spy_called spy, {:times => 3}, :foo
-    end
-  end
-
-  def test_assert_detects_blocks
-    spy.foo { }
-    spy.bar
-    assert_spy_called spy, :foo, Proc
-    assert_spy_called spy, :bar
-  end
-
-  def test_assert_detects_any_args
-    spy.foo
-    spy.foo(1)
-    spy.foo("HI")
-    spy.foo("Hello", "World", 10, :options => true)
-    assert_spy_called spy, {:times => 4}, :foo, :_
-  end
-
-  def test_assert_rejects_bad_count_on_any_args
-    spy.foo
-    assert_fails(/^expected foo\(\.\.\.\) to be received by <FlexMock:AssertSpyCalledTest::FooBar Mock> twice/i) do
-      assert_spy_called spy, {:times => 2}, :foo, :_
-    end
-  end
-
-  def test_assert_error_lists_calls_actually_made_without_handled_by
-    spy.foo
-    spy.bar(1)
-    ex = assert_fails(/The following messages have been received/) do
-      assert_spy_called spy, :baz
-    end
-    assert_match(/  foo\(\)/, ex.message)
-    assert_match(/  bar\(1\)/, ex.message)
-    assert_no_match(/  baz\(\)/, ex.message)
-    assert_no_match(/handled by/, ex.message)
-  end
-
-  def test_assert_error_lists_calls_actually_made_with_handled_by
-    spy.should_receive(:foo).once
-    spy.foo
-    spy.bar(1)
-    ex = assert_fails(/The following messages have been received/) do
-      assert_spy_called spy, :baz
-    end
-    assert_match(/  foo\(\) matched by should_receive\(:foo\)/, ex.message)
-    assert_match(/  bar\(1\)/, ex.message)
-    assert_no_match(/  baz\(\)/, ex.message)
-  end
-
-  def test_assert_errors_say_no_calls_made
-    assert_fails(/No messages have been received/) do
-      assert_spy_called spy, :baz
-    end
-  end
-
-  private
-
-  def assert_fails(message_pattern)
-     ex = assert_raises(FlexMock.framework_adapter.assertion_failed_error) do
-      yield
-    end
-    assert_match(message_pattern, ex.message)
-    ex
-  end
-
-end

data/test/base_class_test.rb

@@ -1,71 +0,0 @@
-require 'test/test_setup'
-
-class BaseClassTest < Test::Unit::TestCase
-  include FlexMock::TestCase
-
-  class FooBar
-    def foo
-    end
-
-    def method_missing(sym, *args, &block)
-      return :poof if sym == :barq
-      super
-    end
-
-    def respond_to?(method)
-      method == :barq || super
-    end
-  end
-
-  def mock
-    @mock ||= flexmock(:on, FooBar)
-  end
-
-  def test_base_class_auto_mocks_class
-    assert_equal FooBar, mock.class
-  end
-
-  def test_base_class_auto_mocks_base_class_methods
-    assert_equal FlexMock.undefined, mock.foo
-  end
-
-  def test_base_class_does_not_mock_non_base_class_methods
-    assert_raise(NoMethodError) do
-      mock.fuzz
-    end
-  end
-
-  def test_can_stub_existing_methods
-    mock.should_receive(:foo => :bar)
-    assert_equal :bar, mock.foo
-  end
-
-  def test_can_not_stub_non_class_defined_methods
-    ex = assert_raises(NoMethodError) do
-      mock.should_receive(:baz => :bar)
-    end
-    assert_match(/can *not stub methods.*base.*class/i, ex.message)
-    assert_match(/class:.+FooBar/i, ex.message)
-    assert_match(/method:.+baz/i, ex.message)
-  end
-
-  def test_can_not_stub_non_class_methods_in_single_line
-    ex = assert_raises(NoMethodError) do
-      flexmock(:on, FooBar, :bark => :value)
-    end
-    assert_match(/can *not stub methods.*base.*class/i, ex.message)
-    assert_match(/class:.+FooBar/i, ex.message)
-    assert_match(/method:.+bark/i, ex.message)
-  end
-
-  def test_can_explicitly_stub_non_class_defined_methods
-    mock.should_receive(:baz).explicitly.and_return(:bar)
-    assert_equal :bar, mock.baz
-  end
-
-  def test_can_explicitly_stub_meta_programmed_methods
-    mock.should_receive(:barq).explicitly.and_return(:bar)
-    assert_equal :bar, mock.barq
-  end
-
-end