mocha 0.5.6 → 3.0.2

data/lib/mocha/mockery.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require 'mocha/central'
+require 'mocha/mock'
+require 'mocha/name'
+require 'mocha/impersonating_name'
+require 'mocha/impersonating_any_instance_name'
+require 'mocha/object_receiver'
+require 'mocha/any_instance_receiver'
+require 'mocha/state_machine'
+require 'mocha/logger'
+require 'mocha/configuration'
+require 'mocha/stubbing_error'
+require 'mocha/not_initialized_error'
+require 'mocha/expectation_error_factory'
+
+module Mocha
+  class Mockery
+    class Null < self
+      def self.build
+        new(nil)
+      end
+
+      def add_mock(*)
+        raise_not_initialized_error
+      end
+
+      def add_state_machine(*)
+        raise_not_initialized_error
+      end
+
+      def stubba
+        Central::Null.new(&method(:raise_not_initialized_error))
+      end
+
+      private
+
+      def raise_not_initialized_error
+        message = 'Mocha methods cannot be used outside the context of a test'
+        raise NotInitializedError.new(message, caller)
+      end
+    end
+
+    class << self
+      def instance
+        @instances.last || Null.build
+      end
+
+      def setup(assertion_counter)
+        @instances ||= []
+        mockery = new(assertion_counter)
+        mockery.logger = instance.logger unless @instances.empty?
+        @instances.push(mockery)
+      end
+
+      def verify
+        instance.verify
+      end
+
+      def teardown(origin = nil)
+        if @instances.nil?
+          raise NotInitializedError, 'Mocha::Mockery.teardown called before Mocha::Mockery.setup'
+        end
+
+        instance.teardown(origin)
+      ensure
+        @instances.pop unless @instances.nil?
+      end
+    end
+
+    def initialize(assertion_counter)
+      @assertion_counter = assertion_counter
+    end
+
+    def named_mock(name)
+      add_mock(Mock.new(self, @assertion_counter, Name.new(name)))
+    end
+
+    def unnamed_mock
+      add_mock(Mock.new(self, @assertion_counter))
+    end
+
+    def mock_impersonating(object)
+      add_mock(Mock.new(self, @assertion_counter, ImpersonatingName.new(object), ObjectReceiver.new(object)))
+    end
+
+    def mock_impersonating_any_instance_of(klass)
+      add_mock(Mock.new(self, @assertion_counter, ImpersonatingAnyInstanceName.new(klass), AnyInstanceReceiver.new(klass)))
+    end
+
+    def new_state_machine(name)
+      add_state_machine(StateMachine.new(name))
+    end
+
+    def verify
+      unless mocks.all?(&:__verified__?)
+        message = "not all expectations were satisfied\n#{mocha_inspect}"
+        backtrace = if unsatisfied_expectations.empty?
+                      caller
+                    else
+                      unsatisfied_expectations[0].backtrace
+                    end
+        raise ExpectationErrorFactory.build(message, backtrace)
+      end
+      expectations.reject(&:used?).each do |expectation|
+        signature_proc = lambda { expectation.method_signature }
+        check(:stubbing_method_unnecessarily, 'method unnecessarily', signature_proc, expectation.backtrace)
+      end
+    end
+
+    def teardown(origin = nil)
+      stubba.unstub_all
+      mocks.each { |m| m.__expire__(origin) }
+      reset
+    end
+
+    def stubba
+      @stubba ||= Central.new
+    end
+
+    def mocks
+      @mocks ||= []
+    end
+
+    def state_machines
+      @state_machines ||= []
+    end
+
+    def sequences
+      @sequences ||= []
+    end
+
+    def mocha_inspect
+      lines = []
+      lines << "unsatisfied expectations:\n- #{unsatisfied_expectations.map(&:mocha_inspect).join("\n- ")}\n" if unsatisfied_expectations.any?
+      lines << "satisfied expectations:\n- #{satisfied_expectations.map(&:mocha_inspect).join("\n- ")}\n" if satisfied_expectations.any?
+      lines << "states:\n- #{state_machines.map(&:mocha_inspect).join("\n- ")}\n" if state_machines.any?
+      lines.join
+    end
+
+    def on_stubbing(object, method)
+      signature_proc = lambda { "#{object.mocha_inspect}.#{method}" }
+      check(:stubbing_non_existent_method, 'non-existent method', signature_proc) do
+        !(object.stubba_class.__method_exists__?(method) || object.stubba_respond_to?(method))
+      end
+      check(:stubbing_non_public_method, 'non-public method', signature_proc) do
+        object.stubba_class.__method_exists__?(method, include_public_methods: false)
+      end
+      check(:stubbing_method_on_non_mock_object, 'method on non-mock object', signature_proc)
+    end
+
+    attr_writer :logger
+
+    def logger
+      @logger ||= Logger.new($stderr)
+    end
+
+    private
+
+    def check(action, description, signature_proc, backtrace = caller)
+      treatment = Mocha.configuration.send(action)
+      return if (treatment == :allow) || (block_given? && !yield)
+
+      method_signature = signature_proc.call
+      message = "stubbing #{description}: #{method_signature}"
+      raise StubbingError.new(message, backtrace) if treatment == :prevent
+
+      logger.warn(message) if treatment == :warn
+    end
+
+    def expectations
+      mocks.map { |mock| mock.__expectations__.to_a }.flatten
+    end
+
+    def unsatisfied_expectations
+      expectations.reject(&:verified?)
+    end
+
+    def satisfied_expectations
+      expectations.select(&:verified?)
+    end
+
+    def add_mock(mock)
+      mocks << mock
+      mock
+    end
+
+    def add_state_machine(state_machine)
+      state_machines << state_machine
+      state_machine
+    end
+
+    def reset
+      @stubba = nil
+      @mocks = nil
+      @state_machines = nil
+    end
+  end
+end

data/lib/mocha/name.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Mocha
+  class Name
+    def initialize(name)
+      @name = name.to_s
+    end
+
+    def mocha_inspect
+      "#<Mock:#{@name}>"
+    end
+  end
+end

data/lib/mocha/not_initialized_error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'mocha/error_with_filtered_backtrace'
+
+module Mocha
+  # Exception raised when Mocha has not been initialized, e.g. outside the
+  # context of a test.
+  class NotInitializedError < ErrorWithFilteredBacktrace; end
+end

data/lib/mocha/object_methods.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require 'mocha/mockery'
+require 'mocha/instance_method'
+require 'mocha/argument_iterator'
+require 'mocha/expectation_error_factory'
+require 'mocha/ignoring_warning'
+
+module Mocha
+  # Methods added to all objects to allow mocking and stubbing on real (i.e. non-mock) objects.
+  #
+  # Both {#expects} and {#stubs} return an {Expectation} which can be further modified by methods on {Expectation}.
+  module ObjectMethods
+    extend IgnoringWarning
+
+    # @private
+    JRUBY_ALIAS_SPECIAL_METHODS_WARNING = /accesses caller method's state and should not be aliased/.freeze
+
+    ignoring_warning(JRUBY_ALIAS_SPECIAL_METHODS_WARNING, if_: RUBY_ENGINE == 'jruby') do
+      alias_method :_method, :method
+    end
+
+    # @private
+    def mocha(instantiate: true)
+      if instantiate
+        @mocha ||= Mocha::Mockery.instance.mock_impersonating(self)
+      else
+        defined?(@mocha) ? @mocha : nil
+      end
+    end
+
+    # @private
+    def reset_mocha
+      @mocha = nil
+    end
+
+    # @private
+    def stubba_method
+      Mocha::InstanceMethod
+    end
+
+    # @private
+    def stubba_object
+      self
+    end
+
+    # @private
+    def stubba_class
+      singleton_class
+    end
+
+    # @private
+    def stubba_respond_to?(symbol)
+      respond_to?(symbol)
+    end
+
+    # Adds an expectation that the specified method must be called exactly once with any parameters.
+    #
+    # The original implementation of the method is replaced during the test and then restored at the end of the test. The temporary replacement method has the same visibility as the original method.
+    #
+    # @return [Expectation] last-built expectation which can be further modified by methods on {Expectation}.
+    # @raise [StubbingError] if attempting to stub method which is not allowed.
+    #
+    # @overload def expects(method_name)
+    #   @param [Symbol,String] method_name name of expected method
+    # @overload def expects(expected_methods_vs_return_values)
+    #   @param [Hash] expected_methods_vs_return_values expected method name symbols as keys and corresponding return values as values - these expectations are setup as if {#expects} were called multiple times.
+    #
+    # @example Setting up an expectation on a non-mock object.
+    #   product = Product.new
+    #   product.expects(:save).returns(true)
+    #   assert_equal true, product.save
+    #
+    # @example Setting up multiple expectations on a non-mock object.
+    #   product = Product.new
+    #   product.expects(valid?: true, save: true)
+    #
+    #   # exactly equivalent to
+    #
+    #   product = Product.new
+    #   product.expects(:valid?).returns(true)
+    #   product.expects(:save).returns(true)
+    #
+    # @see Mock#expects
+    def expects(expected_methods_vs_return_values)
+      if expected_methods_vs_return_values.to_s =~ /the[^a-z]*spanish[^a-z]*inquisition/i
+        raise ExpectationErrorFactory.build('NOBODY EXPECTS THE SPANISH INQUISITION!')
+      end
+      if frozen?
+        raise StubbingError.new("can't stub method on frozen object: #{mocha_inspect}", caller)
+      end
+
+      expectation = nil
+      mockery = Mocha::Mockery.instance
+      iterator = ArgumentIterator.new(expected_methods_vs_return_values)
+      iterator.each do |method_name, *args|
+        mockery.on_stubbing(self, method_name)
+        method = stubba_method.new(stubba_object, method_name)
+        mockery.stubba.stub(method)
+        expectation = mocha.expects(method_name, caller)
+        expectation.returns(args.shift) unless args.empty?
+      end
+      expectation
+    end
+
+    # Adds an expectation that the specified method may be called any number of times with any parameters.
+    #
+    # The original implementation of the method is replaced during the test and then restored at the end of the test. The temporary replacement method has the same visibility as the original method.
+    #
+    # @return [Expectation] last-built expectation which can be further modified by methods on {Expectation}.
+    # @raise [StubbingError] if attempting to stub method which is not allowed.
+    #
+    # @overload def stubs(method_name)
+    #   @param [Symbol,String] method_name name of stubbed method
+    # @overload def stubs(stubbed_methods_vs_return_values)
+    #   @param [Hash] stubbed_methods_vs_return_values stubbed method name symbols as keys and corresponding return values as values - these stubbed methods are setup as if {#stubs} were called multiple times.
+    #
+    # @example Setting up a stubbed methods on a non-mock object.
+    #   product = Product.new
+    #   product.stubs(:save).returns(true)
+    #   assert_equal true, product.save
+    #
+    # @example Setting up multiple stubbed methods on a non-mock object.
+    #   product = Product.new
+    #   product.stubs(valid?: true, save: true)
+    #
+    #   # exactly equivalent to
+    #
+    #   product = Product.new
+    #   product.stubs(:valid?).returns(true)
+    #   product.stubs(:save).returns(true)
+    #
+    # @see Mock#stubs
+    def stubs(stubbed_methods_vs_return_values)
+      if frozen?
+        raise StubbingError.new("can't stub method on frozen object: #{mocha_inspect}", caller)
+      end
+
+      expectation = nil
+      mockery = Mocha::Mockery.instance
+      iterator = ArgumentIterator.new(stubbed_methods_vs_return_values)
+      iterator.each do |method_name, *args|
+        mockery.on_stubbing(self, method_name)
+        method = stubba_method.new(stubba_object, method_name)
+        mockery.stubba.stub(method)
+        expectation = mocha.stubs(method_name, caller)
+        expectation.returns(args.shift) unless args.empty?
+      end
+      expectation
+    end
+
+    # Removes the specified stubbed methods (added by calls to {#expects} or {#stubs}) and all expectations associated with them.
+    #
+    # Restores the original behaviour of the methods before they were stubbed. This is normally done automatically at the end of each test, but in some circumstances you may want to do it *before* the end of the test.
+    #
+    # WARNING: If you {#unstub} a method which still has unsatisfied expectations, you may be removing the only way those expectations can be satisfied. Use {#unstub} with care.
+    #
+    # @param [Array<Symbol>] method_names names of methods to unstub.
+    #
+    # @example Stubbing and unstubbing a method on a real (non-mock) object.
+    #   multiplier = Multiplier.new
+    #   multiplier.double(2) # => 4
+    #   multiplier.stubs(:double).raises # new behaviour defined
+    #   multiplier.double(2) # => raises exception
+    #   multiplier.unstub(:double) # original behaviour restored
+    #   multiplier.double(2) # => 4
+    #
+    # @example Unstubbing multiple methods on a real (non-mock) object.
+    #   multiplier.unstub(:double, :triple)
+    #
+    #   # exactly equivalent to
+    #
+    #   multiplier.unstub(:double)
+    #   multiplier.unstub(:triple)
+    def unstub(*method_names)
+      mockery = Mocha::Mockery.instance
+      method_names.each do |method_name|
+        method = stubba_method.new(stubba_object, method_name)
+        mockery.stubba.unstub(method)
+      end
+    end
+  end
+end

data/lib/mocha/object_receiver.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Mocha
+  class ObjectReceiver
+    def initialize(object)
+      @object = object
+    end
+
+    def mocks
+      object = @object
+      mocks = []
+      while object
+        mocha = object.mocha(instantiate: false)
+        mocks << mocha if mocha
+        object = object.is_a?(Class) ? object.superclass : nil
+      end
+      mocks
+    end
+  end
+end

data/lib/mocha/parameter_matchers/all_of.rb

@@ -1,42 +1,52 @@
-require 'mocha/parameter_matchers/base'
+# frozen_string_literal: true
+
+require 'mocha/parameter_matchers/base_methods'
 
 module Mocha
-  
   module ParameterMatchers
-
-    # :call-seq: all_of -> parameter_matcher
-    #
-    # Matches if all +matchers+ match.
-    #   object = mock()
-    #   object.expects(:method_1).with(all_of(includes(1), includes(3)))
-    #   object.method_1([1, 3])
-    #   # no error raised
-    #
-    #   object = mock()
-    #   object.expects(:method_1).with(all_of(includes(1), includes(3)))
-    #   object.method_1([1, 2])
-    #   # error raised, because method_1 was not called with object including 1 and 3
-    def all_of(*matchers)
-      AllOf.new(*matchers)
+    module Methods
+      # Matches if all +matchers+ match.
+      #
+      # @param [*Array<BaseMethods>] matchers parameter matchers.
+      # @return [AllOf] parameter matcher.
+      #
+      # @see Expectation#with
+      #
+      # @example All parameter matchers match.
+      #   object = mock()
+      #   object.expects(:method_1).with(all_of(includes(1), includes(3)))
+      #   object.method_1([1, 3])
+      #   # no error raised
+      #
+      # @example One of the parameter matchers does not match.
+      #   object = mock()
+      #   object.expects(:method_1).with(all_of(includes(1), includes(3)))
+      #   object.method_1([1, 2])
+      #   # error raised, because method_1 was not called with object including 1 and 3
+      def all_of(*matchers)
+        AllOf.new(*matchers)
+      end
     end
-    
-    class AllOf < Base # :nodoc:
-      
+
+    # Parameter matcher which combines a number of other matchers using a logical AND.
+    class AllOf
+      include BaseMethods
+
+      # @private
       def initialize(*matchers)
         @matchers = matchers
       end
-    
+
+      # @private
       def matches?(available_parameters)
         parameter = available_parameters.shift
-        @matchers.all? { |matcher| matcher.matches?([parameter]) }
+        @matchers.all? { |matcher| matcher.to_matcher.matches?([parameter]) }
       end
-      
+
+      # @private
       def mocha_inspect
-        "all_of(#{@matchers.map { |matcher| matcher.mocha_inspect }.join(", ") })"
+        "all_of(#{@matchers.map(&:mocha_inspect).join(', ')})"
       end
-      
     end
-    
   end
-  
-end
+end

data/lib/mocha/parameter_matchers/any_of.rb

@@ -1,47 +1,58 @@
-require 'mocha/parameter_matchers/base'
+# frozen_string_literal: true
+
+require 'mocha/parameter_matchers/base_methods'
 
 module Mocha
-  
   module ParameterMatchers
-
-    # :call-seq: any_of -> parameter_matcher
-    #
-    # Matches if any +matchers+ match.
-    #   object = mock()
-    #   object.expects(:method_1).with(any_of(1, 3))
-    #   object.method_1(1)
-    #   # no error raised
-    #
-    #   object = mock()
-    #   object.expects(:method_1).with(any_of(1, 3))
-    #   object.method_1(3)
-    #   # no error raised
-    #
-    #   object = mock()
-    #   object.expects(:method_1).with(any_of(1, 3))
-    #   object.method_1(2)
-    #   # error raised, because method_1 was not called with 1 or 3
-    def any_of(*matchers)
-      AnyOf.new(*matchers)
+    module Methods
+      # Matches if any +matchers+ match.
+      #
+      # @param [*Array<BaseMethods>] matchers parameter matchers.
+      # @return [AnyOf] parameter matcher.
+      #
+      # @see Expectation#with
+      #
+      # @example One parameter matcher matches.
+      #   object = mock()
+      #   object.expects(:method_1).with(any_of(1, 3))
+      #   object.method_1(1)
+      #   # no error raised
+      #
+      # @example The other parameter matcher matches.
+      #   object = mock()
+      #   object.expects(:method_1).with(any_of(1, 3))
+      #   object.method_1(3)
+      #   # no error raised
+      #
+      # @example Neither parameter matcher matches.
+      #   object = mock()
+      #   object.expects(:method_1).with(any_of(1, 3))
+      #   object.method_1(2)
+      #   # error raised, because method_1 was not called with 1 or 3
+      def any_of(*matchers)
+        AnyOf.new(*matchers)
+      end
     end
-    
-    class AnyOf < Base # :nodoc:
-      
+
+    # Parameter matcher which combines a number of other matchers using a logical OR.
+    class AnyOf
+      include BaseMethods
+
+      # @private
       def initialize(*matchers)
         @matchers = matchers
       end
-    
+
+      # @private
       def matches?(available_parameters)
         parameter = available_parameters.shift
-        @matchers.any? { |matcher| matcher.matches?([parameter]) }
+        @matchers.any? { |matcher| matcher.to_matcher.matches?([parameter]) }
       end
-      
+
+      # @private
       def mocha_inspect
-        "any_of(#{@matchers.map { |matcher| matcher.mocha_inspect }.join(", ") })"
+        "any_of(#{@matchers.map(&:mocha_inspect).join(', ')})"
       end
-      
     end
-    
   end
-  
-end
+end

data/lib/mocha/parameter_matchers/any_parameters.rb

@@ -1,40 +1,47 @@
-require 'mocha/parameter_matchers/base'
+# frozen_string_literal: true
+
+require 'mocha/parameter_matchers/base_methods'
 
 module Mocha
-  
   module ParameterMatchers
-
-    # :call-seq: any_parameters() -> parameter_matcher
-    #
-    # Matches any parameters.
-    #   object = mock()
-    #   object.expects(:method_1).with(any_parameters)
-    #   object.method_1(1, 2, 3, 4)
-    #   # no error raised
-    #
-    #   object = mock()
-    #   object.expects(:method_1).with(any_parameters)
-    #   object.method_1(5, 6, 7, 8, 9, 0)
-    #   # no error raised
-    def any_parameters
-      AnyParameters.new
+    module Methods
+      # Matches any parameters. This is used as the default for a newly built expectation.
+      #
+      # @return [AnyParameters] parameter matcher.
+      #
+      # @see Expectation#with
+      #
+      # @example Any parameters will match.
+      #   object = mock()
+      #   object.expects(:method_1).with(any_parameters)
+      #   object.method_1(1, 2, 3, 4)
+      #   # no error raised
+      #
+      #   object = mock()
+      #   object.expects(:method_1).with(any_parameters)
+      #   object.method_1(5, 6, 7, 8, 9, 0)
+      #   # no error raised
+      def any_parameters
+        AnyParameters.new
+      end
     end
 
-    class AnyParameters < Base # :nodoc:
-      
+    # Parameter matcher which always matches whatever the parameters.
+    class AnyParameters
+      include BaseMethods
+
+      # @private
       def matches?(available_parameters)
-        while available_parameters.length > 0 do
+        until available_parameters.empty?
           available_parameters.shift
         end
-        return true
+        true
       end
 
+      # @private
       def mocha_inspect
-        "any_parameters"
+        'any_parameters'
       end
-
     end
-    
   end
-  
-end
+end