flexmock 1.3.2 → 1.3.3

data/lib/flexmock/errors.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
 #---
-# Copyright 2003-2012 by Jim Weirich (jim.weirich@gmail.com).
+# Copyright 2003-2013 by Jim Weirich (jim.weirich@gmail.com).
 # All rights reserved.
 #
 # Permission is granted for use, copying, modification, distribution,

data/lib/flexmock/expectation.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
 #---
-# Copyright 2003-2012 by Jim Weirich (jim.weirich@gmail.com).
+# Copyright 2003-2013 by Jim Weirich (jim.weirich@gmail.com).
 # All rights reserved.
 
 # Permission is granted for use, copying, modification, distribution,
@@ -11,10 +11,10 @@
 
 require 'flexmock/noop'
 require 'flexmock/argument_matching'
+require 'flexmock/expectation_recorder'
 
 class FlexMock
 
-  ####################################################################
   # An Expectation is returned from each +should_receive+ message sent
   # to mock object.  Each expectation records how a message matching
   # the message name (argument to +should_receive+) and the argument
@@ -386,7 +386,11 @@ class FlexMock
 
     # Helper method for defining ordered expectations.
     def define_ordered(group_name, ordering)
-      fail UsageError, "Mock #{@mock.flexmock_name} is not in a container and cannot be globally ordered." if ordering.nil?
+      if ordering.nil?
+        fail UsageError,
+          "Mock #{@mock.flexmock_name} " +
+          "is not in a container and cannot be globally ordered."
+      end
       if group_name.nil?
          result = ordering.flexmock_allocate_order
       elsif (num = ordering.flexmock_groups[group_name])
@@ -419,85 +423,4 @@ class FlexMock
 
   end
 
-  ##########################################################################
-  # A composite expectation allows several expectations to be grouped into a
-  # single composite and then apply the same constraints to  all expectations
-  # in the group.
-  class CompositeExpectation
-
-    # Initialize the composite expectation.
-    def initialize
-      @expectations = []
-    end
-
-    # Add an expectation to the composite.
-    def add(expectation)
-      @expectations << expectation
-    end
-
-    # Apply the constraint method to all expectations in the composite.
-    def method_missing(sym, *args, &block)
-      @expectations.each do |expectation|
-        expectation.send(sym, *args, &block)
-      end
-      self
-    end
-
-    # The following methods return a value, so we make an arbitrary choice
-    # and return the value for the first expectation in the composite.
-
-    # Return the order number of the first expectation in the list.
-    def order_number
-      @expectations.first.order_number
-    end
-
-    # Return the associated mock object.
-    def mock
-      @expectations.first.mock
-    end
-
-    # Start a new method expectation.  The following constraints will be
-    # applied to the new expectation.
-    def should_receive(*args, &block)
-      @expectations.first.mock.flexmock_define_expectation(caller.first, *args, &block)
-    end
-
-    # Return a string representations
-    def to_s
-      if @expectations.size > 1
-        "[" + @expectations.collect { |e| e.to_s }.join(', ') + "]"
-      else
-        @expectations.first.to_s
-      end
-    end
-  end
-
-  ##########################################################################
-  # An expectation recorder records any expectations received and plays them
-  # back on demand.  This is used to collect the expectations in the blockless
-  # version of the new_instances call.
-  #
-  class ExpectationRecorder
-
-    # Initialize the recorder.
-    def initialize
-      @expectations = []
-    end
-
-    # Save any incoming messages to be played back later.
-    def method_missing(sym, *args, &block)
-      @expectations << [sym, args, block]
-      self
-    end
-
-    # Apply the recorded messages to the given object in a chaining fashion
-    # (i.e. the result of the previous call is used as the target of the next
-    # call).
-    def apply(mock)
-      obj = mock
-      @expectations.each do |sym, args, block|
-        obj = obj.send(sym, *args, &block)
-      end
-    end
-  end
 end

data/lib/flexmock/expectation_builder.rb

@@ -0,0 +1,133 @@
+#!/usr/bin/env ruby
+
+#---
+# Copyright 2003-2013 by Jim Weirich (jim.weirich@gmail.com).
+# 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 'flexmock/composite_expectation'
+
+class FlexMock
+
+  class ExpectationBuilder
+    # :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 = create_expectation(mock, k, &block).and_return(v)
+            result.add(exp)
+          end
+        when Symbol, String
+          result.add(create_expectation(mock, arg, &block))
+        end
+      end
+      result
+    end
+
+    # Create an expectation for the name on this mock. For simple
+    # mocks, this is done by calling the provided block parameter and
+    # letting the calling site handle the creation of the expectation
+    # (which differs between full mocks and partial mocks).
+    #
+    # If the name_chain contains demeter mocking chains, then the
+    # process is more complex. A series of mocks are created, each
+    # component of the chain returning the next mock until the
+    # expectation for the last component is returned.
+    def create_expectation(mock, name_chain, &block)
+      names = name_chain.to_s.split('.').map { |n| n.to_sym }
+      check_method_names(names)
+      if names.size == 1
+        block.call(names.first)
+      elsif names.size > 1
+        create_demeter_chain(mock, names)
+      else
+        fail "Empty list of names"
+      end
+    end
+
+    # Build the chain of mocks for demeter style mocking.
+    #
+    # 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:
+    #
+    # * 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.
+    #
+    # * 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 create_demeter_chain(mock, names)
+      container = mock.flexmock_container
+      last_method = names.pop
+      names.each do |name|
+        exp = mock.flexmock_find_expectation(name)
+        if exp
+          next_mock = exp._return_value([])
+          check_proper_mock(next_mock, name)
+        else
+          next_mock = container.flexmock("demeter_#{name}")
+          mock.should_receive(name).and_return(next_mock)
+        end
+        mock = next_mock
+      end
+      mock.should_receive(last_method)
+    end
+
+    # Check that the given mock is a real FlexMock mock.
+    def check_proper_mock(mock, method_name)
+      unless mock.respond_to?(:should_receive)
+        fail FlexMock::UsageError,
+          "Conflicting mock declaration for '#{method_name}' in demeter style mock"
+      end
+    end
+
+    METHOD_NAME_ALTS = [
+      '[A-Za-z_][A-Za-z0-9_]*[=!?]?',
+      '\[\]=?',
+      '\*\\*',
+      '<<',
+      '>>',
+      '<=>',
+      '[<>=!]=',
+      '[=!]~',
+      '===',
+      '[-+]@',
+      '[-+\*\/%&^|<>~`!]'
+    ].join("|")
+    METHOD_NAME_RE = /^(#{METHOD_NAME_ALTS})$/
+
+    # 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.to_s !~ METHOD_NAME_RE
+      end
+    end
+  end
+
+  EXP_BUILDER = ExpectationBuilder.new
+end

data/lib/flexmock/expectation_director.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
 #---
-# Copyright 2003-2012 by Jim Weirich (jim.weirich@gmail.com).
+# Copyright 2003-2013 by Jim Weirich (jim.weirich@gmail.com).
 # All rights reserved.
 
 # Permission is granted for use, copying, modification, distribution,
@@ -13,7 +13,7 @@ require 'flexmock/noop'
 require 'flexmock/errors'
 
 class FlexMock
-  ####################################################################
+
   # The expectation director is responsible for routing calls to the
   # correct expectations for a given argument list.
   #
@@ -39,8 +39,10 @@ class FlexMock
       exp = find_expectation(*args)
       call_record.expectation = exp if call_record
       FlexMock.check(
-        "no matching handler found for " + FlexMock.format_call(@sym, args)) { ! exp.nil? }
-      exp.verify_call(*args)
+        "no matching handler found for " +
+        FlexMock.format_call(@sym, args)) { ! exp.nil? }
+      returned_value = exp.verify_call(*args)
+      returned_value
     end
 
     # Append an expectation to this director.

data/lib/flexmock/expectation_recorder.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+#---
+# Copyright 2003-2013 by Jim Weirich (jim.weirich@gmail.com).
+# 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
+
+  # An expectation recorder records any expectations received and plays them
+  # back on demand.  This is used to collect the expectations in the blockless
+  # version of the new_instances call.
+  #
+  class ExpectationRecorder
+
+    # Initialize the recorder.
+    def initialize
+      @expectations = []
+    end
+
+    # Save any incoming messages to be played back later.
+    def method_missing(sym, *args, &block)
+      @expectations << [sym, args, block]
+      self
+    end
+
+    # Apply the recorded messages to the given object in a chaining fashion
+    # (i.e. the result of the previous call is used as the target of the next
+    # call).
+    def apply(mock)
+      obj = mock
+      @expectations.each do |sym, args, block|
+        obj = obj.send(sym, *args, &block)
+      end
+    end
+  end
+
+end

data/lib/flexmock/extensions/active_record_model.rb

@@ -0,0 +1,109 @@
+require 'flexmock/mock_container'
+
+class FlexMock
+  module Extensions
+
+    class ActiveRecordModel
+      # Handle the argument list.
+      #
+      # This method is called whenever an unrecognized symbol is
+      # detected in the flexmock argument list. If the extension class
+      # can handle it, it should return true.
+      #
+      # Extension data can be stored in the opts.data hash for later use
+      # during the create and post_create phase.
+      def handle(args, opts)
+        return false unless args.first == :model
+        args.shift
+        opts.data[:model_class] = args.shift
+        opts.extended = self
+        true
+      end
+
+      # Create the test double.
+      #
+      # Create the custome test double according to the data from the
+      # argument list. The object returned from this method is the
+      # object returned from the original flexmock() method call. This
+      # the returned object is NOT the actual mock object (which is the
+      # case for things like partial proxies), then the opts.mock field
+      # should be set to contain the actual mock object.
+      def create(container, opts)
+        id = next_id
+        FlexMock.new("#{opts.data[:model_class]}_#{id}", container)
+      end
+
+      # Do any post-creation setup on the mock object.
+      def post_create(opts, location)
+        add_model_methods(opts.mock, opts.data[:model_class], location)
+      end
+
+      private
+
+      # Return the next id for mocked models.
+      def next_id
+        @id_counter ||= 10000
+        @id_counter += 1
+      end
+
+      def current_id
+        @id_counter
+      end
+
+      # Automatically add mocks for some common methods in ActiveRecord
+      # models.
+      def add_model_methods(mock, model_class, location)
+        add_model_methods_returning_values(mock, location,
+          [:id,          current_id                                 ],
+          [:to_params,   current_id.to_s                            ],
+          [:new_record?, false                                      ],
+          [:class,       model_class                                ],
+          [:errors,      make_mock_model_errors_for(mock, location) ])
+
+        add_model_methods_with_behavior(mock, location,
+          [:is_a?,        lambda { |other| other == model_class }                  ],
+          [:instance_of?, lambda { |other| other == model_class }                  ],
+          [:kind_of?,     lambda { |other| model_class.ancestors.include?(other) } ])
+      end
+
+      def add_model_methods_returning_values(mock, location, *pairs)
+        pairs.each do |method, retval|
+          make_default_behavior(mock, location, method, retval)
+        end
+      end
+
+      def add_model_methods_with_behavior(mock, location, *pairs)
+        pairs.each do |method, block|
+          make_default_behavior(mock, location, method, &block)
+        end
+      end
+
+      # Create a mock model errors object (with default behavior).
+      def make_mock_model_errors_for(mock, location)
+        result = mock.flexmock_container.flexmock("errors")
+        make_default_behavior(result, location, :count, 0)
+        make_default_behavior(result, location, :full_messages, [])
+        result
+      end
+
+      # Define default behavior on a mock object.
+      #
+      # If a block is given, use that to define the behavior. Otherwise
+      # return the +retval+ value.
+      def make_default_behavior(mock, location, method, retval=nil, &block)
+        if block_given?
+          mock.flexmock_define_expectation(location, method).
+            with(FlexMock.any).
+            and_return(&block).
+            by_default
+        else
+          mock.flexmock_define_expectation(location, method).
+            and_return(retval).
+            by_default
+        end
+      end
+    end
+
+    FlexMock::CONTAINER_HELPER.add_extension(ActiveRecordModel.new)
+  end
+end

data/lib/flexmock/mock_builder.rb

@@ -0,0 +1,139 @@
+class FlexMock
+
+  # This class contains helper methods for mock containers. Since
+  # MockContainer is a module that is designed to be mixed into other
+  # classes, (particularly testing framework test cases), we don't
+  # want to pollute the method namespace of the class that mixes in
+  # MockContainer. So we have aggressively moved a number of
+  # MockContainer methods out of that class and into
+  # MockBuilder to isoloate the names.
+  #
+  class MockBuilder
+    def initialize(container)
+      @container = container
+    end
+
+    def define_a_mock(location, *args, &block)
+      opts = parse_creation_args(args)
+      if opts.safe_mode && ! block_given?
+        raise UsageError, "a block is required in safe mode"
+      end
+
+      result = create_double(opts)
+      flexmock_mock_setup(opts.mock, opts, location, &block)
+      run_post_creation_hooks(opts, location)
+      result
+    end
+
+    FlexOpts = Struct.new(
+      :name, :defs, :safe_mode, :mock,
+      :domain_obj, :base_class,
+      :extended, :extended_data
+      ) do
+      def data
+        self.extended_data ||= {}
+      end
+    end
+
+    # Parse the list of flexmock() arguments and populate the opts object.
+    def parse_creation_args(args)
+      opts = FlexOpts.new
+      while ! args.empty?
+        case args.first
+        when Symbol
+          unless parse_create_symbol(args, opts)
+            opts.name = args.shift.to_s
+          end
+        when String, Symbol
+          opts.name = args.shift.to_s
+        when Hash
+          opts.defs = args.shift
+        when FlexMock
+          opts.mock = args.shift
+        else
+          opts.domain_obj = args.shift
+        end
+      end
+      set_base_class(opts)
+      opts
+    end
+
+    # Create the test double based on the args options.
+    def create_double(opts)
+      if opts.extended
+        result = opts.extended.create(container, opts)
+      elsif opts.domain_obj
+        result = create_partial(opts)
+      else
+        result = create_mock(opts)
+      end
+      opts.mock ||= result
+      result
+    end
+
+    # Run any post creation hooks specified by an extension.
+    def run_post_creation_hooks(opts, location)
+      if opts.extended
+        opts.extended.post_create(opts, location)
+      end
+    end
+
+
+    # Setup the test double with its expections and such.
+    def flexmock_mock_setup(mock, opts, location)
+      mock.flexmock_based_on(opts.base_class) if opts.base_class
+      mock.flexmock_define_expectation(location, opts.defs)
+      yield(mock) if block_given?
+      container.flexmock_remember(mock)
+    end
+
+    attr_reader :container
+    private :container
+
+    private
+
+    # Set the base class if not defined and partials are based.
+    def set_base_class(opts)
+      if ! opts.base_class && opts.domain_obj && FlexMock.partials_are_based
+        opts.base_class = opts.domain_obj.class
+      end
+    end
+
+    # Handle a symbol in the flexmock() args list.
+    def parse_create_symbol(args, opts)
+      case args.first
+      when :base, :safe
+        opts.safe_mode = (args.shift == :safe)
+        opts.domain_obj = args.shift
+      when :on
+        args.shift
+        opts.base_class = args.shift
+        opts.name ||= "#{opts.base_class} Mock"
+      else
+        CONTAINER_HELPER.extensions.each do |ext|
+          handled = ext.handle(args, opts)
+          return true if handled
+        end
+        return false
+      end
+      true
+    end
+
+    # Create a mock object in the options.
+    def create_mock(opts)
+      opts.mock ||= FlexMock.new(opts.name || "unknown", container)
+      opts.mock
+    end
+
+    # Create a partial mock object in options.
+    def create_partial(opts)
+      opts.mock = PartialMockProxy.make_proxy_for(
+        opts.domain_obj,
+        container, opts.name,
+        opts.safe_mode)
+      opts.domain_obj
+    end
+
+  end
+
+end