flexmock 0.6.4 → 0.7.0

data/lib/flexmock/expectation_director.rb

@@ -35,13 +35,18 @@ class FlexMock
     # check for expectations that don't have any argument matching
     # criteria.
     def call(*args)
-      exp = @expectations.find { |e| e.match_args(args) && e.eligible? } ||
-      @expectations.find { |e| e.match_args(args) }
+      exp = find_expectation(*args)
       FlexMock.check("no matching handler found for " +
-      FlexMock.format_args(@sym, args)) { ! exp.nil? }
+        FlexMock.format_args(@sym, args)) { ! exp.nil? }
       exp.verify_call(*args)
     end
 
+    # Find an expectation matching the given arguments.
+    def find_expectation(*args)
+      @expectations.find { |e| e.match_args(args) && e.eligible? } ||
+        @expectations.find { |e| e.match_args(args) }
+    end
+    
     # Append an expectation to this director.
     def <<(expectation)
       @expectations << expectation
@@ -49,9 +54,9 @@ class FlexMock
 
     # Do the post test verification for this directory.  Check all the
     # expectations.
-    def mock_verify
+    def flexmock_verify
       @expectations.each do |exp|
-        exp.mock_verify
+        exp.flexmock_verify
       end
     end
   end

data/lib/flexmock/mock_container.rb

@@ -10,6 +10,7 @@
 #+++
 
 require 'flexmock/noop'
+require 'flexmock/argument_types'
 
 class FlexMock
   
@@ -22,6 +23,8 @@ class FlexMock
   # verified in the teardown of the test case.
   #   
   module MockContainer
+    include Ordering
+
     # Do the flexmock specific teardown stuff.  If you need finer control,
     # you can use either +flexmock_verify+ or +flexmock_close+.
     def flexmock_teardown
@@ -34,7 +37,7 @@ class FlexMock
     def flexmock_verify
       @flexmock_created_mocks ||= []
       @flexmock_created_mocks.each do |m|
-        m.mock_verify
+        m.flexmock_verify
       end
     end
     
@@ -43,7 +46,7 @@ class FlexMock
     def flexmock_close
       @flexmock_created_mocks ||= []
       @flexmock_created_mocks.each do |m|
-        m.mock_teardown
+        m.flexmock_teardown
       end
       @flexmock_created_mocks = []
     end
@@ -134,68 +137,180 @@ class FlexMock
       raise UsageError, "a block is required in safe mode" if safe_mode && ! block_given?
 
       if domain_obj
-        mock = flexmock_make_partial_proxy(domain_obj, name, safe_mode)
+        mock = ContainerHelper.make_partial_proxy(self, domain_obj, name, safe_mode)
         result = domain_obj
       elsif model_class
-        id = MockContainer.next_id
-        result = mock = FlexMock.new("#{model_class}_#{id}")
+        id = ContainerHelper.next_id
+        result = mock = FlexMock.new("#{model_class}_#{id}", self)
       else
-        result = mock = FlexMock.new(name || "unknown")
+        result = mock = FlexMock.new(name || "unknown", self)
       end
-      flexmock_quick_define(mock, quick_defs)
+      mock.should_receive(quick_defs)
       yield(mock) if block_given?
       flexmock_remember(mock)
-      flexmock_mock_model_methods(mock, model_class, id) if model_class
+      ContainerHelper.add_model_methods(mock, model_class, id) if model_class
       result
     end
     alias flexstub flexmock
     
-    private
-    
+    # Remember the mock object / stub in the mock container.
+    def flexmock_remember(mocking_object)
+      @flexmock_created_mocks ||= []
+      @flexmock_created_mocks << mocking_object
+      mocking_object.flexmock_container = self
+      mocking_object
+    end
+  end
+
+  # #################################################################
+  # Helper methods for mock containers.  MockContainer is a module
+  # that is designed to be mixed into other classes, particularly
+  # testing framework test cases.  Since we don't want to pollute the
+  # method namespace of the class that mixes in MockContainer, a
+  # number of MockContainer methods were moved into ContainerHelper to
+  # to isoloate the names.
+  #
+  class MockContainerHelper
+    include FlexMock::ArgumentTypes
+
+    # Return the next id for mocked models.
+    def next_id
+      @id_counter ||= 0
+      @id_counter += 1
+    end
+
+    # :call-seq:
+    #   parse_should_args(args) { |symbol| ... }
+    #
+    # This method provides common handling for the various should_receive
+    # argument lists. It sorts out the differences between symbols, arrays and
+    # hashes, and identifies the method names specified by each.  As each
+    # method name is identified, create a mock expectation for it using the
+    # supplied block.
+    def parse_should_args(mock, args, &block)  # :nodoc:
+      result = CompositeExpectation.new
+      args.each do |arg|
+        case arg
+        when Hash
+          arg.each do |k,v|
+            exp = build_demeter_chain(mock, k, &block).and_return(v)
+            result.add(exp)
+          end
+        when Symbol, String
+          result.add(build_demeter_chain(mock, arg, &block))
+        end
+      end
+      result
+    end
+
     # Automatically add mocks for some common methods in ActiveRecord
     # models.
-    def flexmock_mock_model_methods(mock, model_class, id)
+    def add_model_methods(mock, model_class, id)
+      container = mock.flexmock_container
       mock.should_receive(
         :id => id,
         :to_params => id.to_s,
         :new_record? => false,
         :class => model_class,
-        :errors => flexmock("errors", :count => 0))
+        :errors => container.flexmock("errors", :count => 0))
       mock.should_receive(:is_a?).with(any).and_return { |other|
         other == model_class
       }
+      mock.should_receive(:instance_of?).with(any).and_return { |other|
+        other == model_class
+      }
+      mock.should_receive(:kind_of?).with(any).and_return { |other|
+        model_class.ancestors.include?(other)
+      }
     end
 
     # Create a PartialMockProxy for the given object.  Use +name+ as
     # the name of the mock object.
-    def flexmock_make_partial_proxy(obj, name, safe_mode)
+    def make_partial_proxy(container, obj, name, safe_mode)
       name ||= "flexmock(#{obj.class.to_s})"
       obj.instance_eval {
-        @flexmock_proxy ||= PartialMockProxy.new(obj, FlexMock.new(name), safe_mode)
+        mock = FlexMock.new(name, container)
+        @flexmock_proxy ||= PartialMockProxy.new(obj, mock, safe_mode)
       }
       obj.instance_variable_get("@flexmock_proxy")
     end
 
-    # Create a set of mocked methods from a hash.
-    def flexmock_quick_define(mock, defs)
-      defs.each do |method, value|
-        mock.should_receive(method).and_return(value)
+    private
+    
+    # Build the chain of mocks for demeter style mocking.
+    #
+    # Warning: Nasty code ahead.
+    #
+    # This method builds a chain of mocks to support demeter style
+    # mocking.  Given a mock chain of "first.second.third.last", we
+    # must build a chain of mock methods that return the next mock in
+    # the chain.  The expectation for the last method of the chain is
+    # returned as the result of the method.
+    #
+    # Things to consider:
+    #
+    # (1) The expectation for the "first" method must be created by
+    # the proper mechanism, which is supplied by the block parameter
+    # "block".  In other words, first expectation is created by
+    # calling the block.  (This allows us to create expectations on
+    # both pure mocks and partial mocks, with the block handling the
+    # details).
+    #
+    # (2) Although the first mock is arbitrary, the remaining mocks in
+    # the chain will always be pure mocks created specifically for
+    # this purpose.
+    #
+    # (3) The expectations for all methods but the last in the chain
+    # will be setup to expect no parameters and to return the next
+    # mock in the chain.
+    #
+    # (4) It could very well be the case that several demeter chains
+    # will be defined on a single mock object, and those chains could
+    # share some of the same methods (e.g. "mock.one.two.read" and
+    # "mock.one.two.write" both share the methods "one" and "two").
+    # It is important that the shared methods return the same mocks in
+    # both chains.
+    #
+    def build_demeter_chain(mock, arg, &block)
+      container = mock.flexmock_container
+      names = arg.to_s.split('.')
+      check_method_names(names)
+      exp = nil
+      next_exp = lambda { |n| block.call(n) }
+      loop do
+        method_name = names.shift.to_sym
+        exp = mock.flexmock_find_expectation(method_name)
+        need_new_exp = exp.nil? || names.empty?
+        exp = next_exp.call(method_name) if need_new_exp
+        break if names.empty?
+        if need_new_exp
+          mock = container.flexmock("demeter_#{method_name}")
+          exp.with_no_args.and_return(mock)
+        else
+          mock = exp._return_value([])
+        end
+        check_proper_mock(mock, method_name)
+        next_exp = lambda { |n| mock.should_receive(n) }
       end
-      mock
+      exp
     end
     
-    # Remember the mock object / stub in the mock container.
-    def flexmock_remember(mocking_object)
-      @flexmock_created_mocks ||= []
-      @flexmock_created_mocks << mocking_object
-      mocking_object.mock_container = self
-      mocking_object
+    # Check that the given mock is a real FlexMock mock.
+    def check_proper_mock(mock, method_name)
+      unless mock.kind_of?(FlexMock)
+        fail FlexMock::UsageError,
+          "Conflicting mock declaration for '#{method_name}' in demeter style mock"
+      end
     end
-
-    def MockContainer.next_id
-      @id_counter ||= 0
-      @id_counter += 1
+    
+    # Check that all the names in the list are valid method names.
+    def check_method_names(names)
+      names.each do |name|
+        fail FlexMock::UsageError, "Ill-formed method name '#{name}'" if
+          name !~ /^[A-Za-z_][A-Za-z0-9_]*[=!?]?$/
+      end
     end
   end
 
+  ContainerHelper = MockContainerHelper.new
 end

data/lib/flexmock/ordering.rb

@@ -0,0 +1,51 @@
+#!/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.
+#+++
+
+class FlexMock
+
+  # #################################################################
+  # The ordering module contains the methods and data structures used
+  # to determine proper orderring of mocked calls.  By providing the
+  # functionality in a module, a individual mock object can order its
+  # own calls, and the container can provide ordering at a global
+  # level.
+  module Ordering
+
+    # Allocate the next available order number.
+    def flexmock_allocate_order
+      @flexmock_allocated_order ||= 0
+      @flexmock_allocated_order += 1
+    end
+
+    # Hash of groups defined in this ordering.
+    def flexmock_groups
+      @flexmock_groups ||= {}
+    end
+
+    # Current order number in this ordering.
+    def flexmock_current_order
+      @flexmock_current_order ||= 0
+    end
+
+    # Set the current order for this ordering.
+    def flexmock_current_order=(value)
+      @flexmock_current_order = value
+    end
+
+    def flexmock_validate_order(method_name, order_number)
+      FlexMock.check("method #{method_name} called out of order " +
+        "(expected order #{order_number}, was #{flexmock_current_order})") {
+        order_number >= self.flexmock_current_order
+      }
+      self.flexmock_current_order = order_number
+    end
+  end
+end

data/lib/flexmock/partial_mock.rb

@@ -24,15 +24,16 @@ class FlexMock
   # (e.g.  remove instance variables and mock singleton methods).
   #
   class PartialMockProxy
-    attr_reader :mock, :mock_groups
-    attr_accessor :mock_current_order, :mock_container
+    include Ordering
+
+    attr_reader :mock
 
     # The following methods are added to partial mocks so that they
     # can act like a mock.
     
     MOCK_METHODS = [
-      :should_receive, :new_instances, :any_instance,
-      :mock,           :mock_teardown, :mock_verify
+      :should_receive, :new_instances, 
+      :flexmock_get,   :flexmock_teardown, :flexmock_verify
     ]
 
     # Initialize a PartialMockProxy object.
@@ -41,9 +42,6 @@ class FlexMock
       @mock = mock
       @method_definitions = {}
       @methods_proxied = []
-      @allocated_order = 0
-      @mock_current_order = 0
-      @mock_groups = {}
       unless safe_mode
         MOCK_METHODS.each do |sym|
           add_mock_method(@obj, sym)
@@ -51,6 +49,11 @@ class FlexMock
       end
     end
 
+    # Get the mock object for the partial mock.
+    def flexmock_get
+      @mock
+    end
+
     # :call-seq:
     #    should_receive(:method_name)
     #    should_receive(:method1, method2, ...)
@@ -72,7 +75,7 @@ class FlexMock
     #
     # See Expectation for a list of declarators that can be used.
     def should_receive(*args)
-      FlexMock.should_receive(args) do |sym|
+      ContainerHelper.parse_should_args(@mock, args) do |sym|
         unless @methods_proxied.include?(sym)
           hide_existing_method(sym)
         end
@@ -115,7 +118,7 @@ class FlexMock
       allocators.each do |m|
         self.should_receive(m).and_return { |*args|
           new_obj = invoke_original(m, args)
-          mock = mock_container.flexmock(new_obj)
+          mock = flexmock_container.flexmock(new_obj)
           block.call(mock) if block_given?
           result.apply(mock)
           new_obj
@@ -124,13 +127,6 @@ class FlexMock
       result
     end
 
-    # any_instance is present for backwards compatibility with version 0.5.0.
-    # @deprecated
-    def any_instance(&block)
-      $stderr.puts "any_instance is deprecated, use new_instances instead."
-      new_instances(&block)
-    end
-
     # Invoke the original definition of method on the object supported by
     # the stub.
     def invoke_original(method, args)
@@ -141,12 +137,12 @@ class FlexMock
 
     # Verify that the mock has been properly called.  After verification,
     # detach the mocking infrastructure from the existing object.
-    def mock_verify
-      @mock.mock_verify
+    def flexmock_verify
+      @mock.flexmock_verify
     end
 
     # Remove all traces of the mocking framework from the existing object.
-    def mock_teardown
+    def flexmock_teardown
       if ! detached?
         @methods_proxied.each do |method_name|
           remove_current_method(method_name)
@@ -157,9 +153,14 @@ class FlexMock
       end
     end
 
-    # Allocation a new order number from the mock.
-    def mock_allocate_order
-      @allocated_order += 1
+    # Forward to the mock's container.
+    def flexmock_container
+      @mock.flexmock_container
+    end
+
+    # Set the proxy's mock container.  This set value is ignored
+    # because the proxy always uses the container of its mock.
+    def flexmock_container=(container)
     end
 
     private

data/test/asserts.rb

@@ -0,0 +1,34 @@
+#!/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.
+#+++
+
+class FlexMock
+
+  # Provide a common failure assertion.
+  module FailureAssertion
+    private
+
+    # 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
+end