jferris-mocha 0.9.5.0.1240002286

data/lib/mocha/mockery.rb

@@ -0,0 +1,189 @@
+require 'mocha/central'
+require 'mocha/mock'
+require 'mocha/names'
+require 'mocha/state_machine'
+require 'mocha/logger'
+require 'mocha/configuration'
+require 'mocha/stubbing_error'
+require 'mocha/invocation'
+
+module Mocha
+  
+  class Mockery
+    
+    class << self
+      
+      def instance
+        @instance ||= new
+      end
+      
+      def reset_instance
+        @instance = nil
+      end
+      
+    end
+    
+    def named_mock(name, &block)
+      add_mock(Mock.new(Name.new(name), &block))
+    end
+    
+    def unnamed_mock(&block)
+      add_mock(Mock.new(&block))
+    end
+    
+    def mock_impersonating(object, &block)
+      add_mock(Mock.new(ImpersonatingName.new(object), &block))
+    end
+    
+    def mock_impersonating_any_instance_of(klass, &block)
+      add_mock(Mock.new(ImpersonatingAnyInstanceName.new(klass), &block))
+    end
+    
+    def new_state_machine(name)
+      add_state_machine(StateMachine.new(name))
+    end
+
+    def invocation(mock, method_name, args)
+      invocations << Invocation.new(mock, method_name, args)
+    end
+    
+    def verify(assertion_counter = nil)
+      unless mocks.all? { |mock| mock.__verified__?(assertion_counter) }
+        message = "not all expectations were satisfied\n#{mocha_inspect}"
+        if unsatisfied_expectations.empty?
+          backtrace = caller
+        else
+          backtrace = unsatisfied_expectations[0].backtrace
+        end
+        raise ExpectationError.new(message, backtrace)
+      end
+      expectations.each do |e|
+        unless Mocha::Configuration.allow?(:stubbing_method_unnecessarily)
+          unless e.used?
+            on_stubbing_method_unnecessarily(e)
+          end
+        end
+      end
+    end
+    
+    def teardown
+      stubba.unstub_all
+      reset
+    end
+    
+    def stubba
+      @stubba ||= Central.new
+    end
+    
+    def mocks
+      @mocks ||= []
+    end
+    
+    def state_machines
+      @state_machines ||= []
+    end
+
+    def mocha_inspect
+      message = ""
+      message << "unsatisfied expectations:\n- #{unsatisfied_expectations.map { |e| e.mocha_inspect }.join("\n- ")}\n" unless unsatisfied_expectations.empty?
+      message << "satisfied expectations:\n- #{satisfied_expectations.map { |e| e.mocha_inspect }.join("\n- ")}\n" unless satisfied_expectations.empty?
+      message << "states:\n- #{state_machines.map { |sm| sm.mocha_inspect }.join("\n- ")}" unless state_machines.empty?
+      message
+    end
+    
+    def on_stubbing(object, method)
+      method = RUBY_VERSION < '1.9' ? method.to_s : method.to_sym
+      unless Mocha::Configuration.allow?(:stubbing_non_existent_method)
+        unless object.method_exists?(method, include_public_methods = true)
+          on_stubbing_non_existent_method(object, method)
+        end
+      end
+      unless Mocha::Configuration.allow?(:stubbing_non_public_method)
+        if object.method_exists?(method, include_public_methods = false)
+          on_stubbing_non_public_method(object, method)
+        end
+      end
+      unless Mocha::Configuration.allow?(:stubbing_method_on_non_mock_object)
+        on_stubbing_method_on_non_mock_object(object, method)
+      end
+    end
+    
+    def on_stubbing_non_existent_method(object, method)
+      if Mocha::Configuration.prevent?(:stubbing_non_existent_method)
+        raise StubbingError.new("stubbing non-existent method: #{object.mocha_inspect}.#{method}", caller)
+      end
+      if Mocha::Configuration.warn_when?(:stubbing_non_existent_method)
+        logger.warn "stubbing non-existent method: #{object.mocha_inspect}.#{method}"
+      end
+    end
+    
+    def on_stubbing_non_public_method(object, method)
+      if Mocha::Configuration.prevent?(:stubbing_non_public_method)
+        raise StubbingError.new("stubbing non-public method: #{object.mocha_inspect}.#{method}", caller)
+      end
+      if Mocha::Configuration.warn_when?(:stubbing_non_public_method)
+        logger.warn "stubbing non-public method: #{object.mocha_inspect}.#{method}"
+      end
+    end
+    
+    def on_stubbing_method_on_non_mock_object(object, method)
+      if Mocha::Configuration.prevent?(:stubbing_method_on_non_mock_object)
+        raise StubbingError.new("stubbing method on non-mock object: #{object.mocha_inspect}.#{method}", caller)
+      end
+      if Mocha::Configuration.warn_when?(:stubbing_method_on_non_mock_object)
+        logger.warn "stubbing method on non-mock object: #{object.mocha_inspect}.#{method}"
+      end
+    end
+    
+    def on_stubbing_method_unnecessarily(expectation)
+      if Mocha::Configuration.prevent?(:stubbing_method_unnecessarily)
+        raise StubbingError.new("stubbing method unnecessarily: #{expectation.method_signature}", expectation.backtrace)
+      end
+      if Mocha::Configuration.warn_when?(:stubbing_method_unnecessarily)
+        logger.warn "stubbing method unnecessarily: #{expectation.method_signature}"
+      end
+    end
+    
+    attr_writer :logger
+    
+    def logger
+      @logger ||= Logger.new($stderr)
+    end
+
+    def invocations
+      @invocations ||= []
+    end
+    
+    private
+    
+    def expectations
+      mocks.map { |mock| mock.expectations.to_a }.flatten
+    end
+    
+    def unsatisfied_expectations
+      expectations.reject { |e| e.verified? }
+    end
+    
+    def satisfied_expectations
+      expectations.select { |e| e.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/module_method.rb

@@ -0,0 +1,16 @@
+require 'mocha/module_method'
+
+module Mocha
+
+  class ModuleMethod < ClassMethod
+
+    def method_exists?(method)
+      return true if stubbee.public_methods(false).include?(method)
+      return true if stubbee.protected_methods(false).include?(method)
+      return true if stubbee.private_methods(false).include?(method)
+      return false
+    end
+
+  end
+  
+end

data/lib/mocha/multiple_yields.rb

@@ -0,0 +1,20 @@
+module Mocha # :nodoc:
+  
+  class MultipleYields # :nodoc:
+    
+    attr_reader :parameter_groups
+    
+    def initialize(*parameter_groups)
+      @parameter_groups = parameter_groups
+    end
+    
+    def each
+      @parameter_groups.each do |parameter_group|
+        yield(parameter_group)
+      end
+    end
+    
+  end
+  
+end
+    

data/lib/mocha/names.rb

@@ -0,0 +1,53 @@
+module Mocha
+  
+  class ImpersonatingName
+    
+    def initialize(object)
+      @object = object
+    end
+    
+    def mocha_inspect
+      @object.mocha_inspect
+    end
+    
+  end
+  
+  class ImpersonatingAnyInstanceName
+    
+    def initialize(klass)
+      @klass = klass
+    end
+    
+    def mocha_inspect
+      "#<AnyInstance:#{@klass.mocha_inspect}>"
+    end
+    
+  end
+  
+  class Name
+    
+    def initialize(name)
+      @name = name
+    end
+    
+    def mocha_inspect
+      "#<Mock:#{@name}>"
+    end
+    
+  end
+  
+  class DefaultName
+    
+    def initialize(mock)
+      @mock = mock
+    end
+    
+    def mocha_inspect
+      address = @mock.__id__ * 2
+      address += 0x100000000 if address < 0
+      "#<Mock:0x#{'%x' % address}>"
+    end
+    
+  end
+  
+end

data/lib/mocha/no_yields.rb

@@ -0,0 +1,11 @@
+module Mocha # :nodoc:
+  
+  class NoYields # :nodoc:
+    
+    def each
+    end
+    
+  end
+  
+end
+    

data/lib/mocha/object.rb

@@ -0,0 +1,187 @@
+require 'mocha/mockery'
+require 'mocha/instance_method'
+require 'mocha/class_method'
+require 'mocha/module_method'
+require 'mocha/any_instance_method'
+require 'mocha/argument_iterator'
+
+module Mocha
+  
+  # Methods added all objects to allow mocking and stubbing on real objects.
+  #
+  # Methods return a Mocha::Expectation which can be further modified by methods on Mocha::Expectation.
+  module ObjectMethods
+  
+    def mocha # :nodoc:
+      @mocha ||= Mocha::Mockery.instance.mock_impersonating(self)
+    end
+  
+    def reset_mocha # :nodoc:
+      @mocha = nil
+    end
+  
+    def stubba_method # :nodoc:
+      Mocha::InstanceMethod
+    end
+  
+    def stubba_object # :nodoc:
+      self
+    end
+  
+    # :call-seq: expects(method_name) -> expectation
+    #            expects(method_names_vs_return_values) -> last expectation
+    #
+    # Adds an expectation that a method identified by +method_name+ Symbol must be called exactly once with any parameters.
+    # Returns the new expectation which can be further modified by methods on Mocha::Expectation.
+    #   product = Product.new
+    #   product.expects(:save).returns(true)
+    #   assert_equal true, product.save
+    #
+    # The original implementation of <tt>Product#save</tt> is replaced temporarily.
+    #
+    # The original implementation of <tt>Product#save</tt> is restored at the end of the test.
+    #
+    # If +method_names_vs_return_values+ is a +Hash+, an expectation will be set up for each entry using the key as +method_name+ and value as +return_value+.
+    #   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)
+    def expects(method_name_or_hash)
+      expectation = nil
+      mockery = Mocha::Mockery.instance
+      iterator = ArgumentIterator.new(method_name_or_hash)
+      iterator.each { |*args|
+        method_name = args.shift
+        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) if args.length > 0
+      }
+      expectation
+    end
+  
+    # :call-seq: stubs(method_name) -> expectation
+    #            stubs(method_names_vs_return_values) -> last expectation
+    #
+    # Adds an expectation that a method identified by +method_name+ Symbol may be called any number of times with any parameters.
+    # Returns the new expectation which can be further modified by methods on Mocha::Expectation.
+    #   product = Product.new
+    #   product.stubs(:save).returns(true)
+    #   assert_equal true, product.save
+    #
+    # The original implementation of <tt>Product#save</tt> is replaced temporarily.
+    #
+    # The original implementation of <tt>Product#save</tt> is restored at the end of the test.
+    #
+    # If +method_names_vs_return_values+ is a +Hash+, an expectation will be set up for each entry using the key as +method_name+ and value as +return_value+.
+    #   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)
+    def stubs(method_name_or_hash)
+      expectation = nil
+      mockery = Mocha::Mockery.instance
+      iterator = ArgumentIterator.new(method_name_or_hash)
+      iterator.each { |*args|
+        method_name = args.shift
+        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) if args.length > 0
+      }
+      expectation
+    end
+  
+    def method_exists?(method, include_public_methods = true) # :nodoc:
+      if include_public_methods
+        return true if public_methods(include_superclass_methods = true).include?(method)
+        return true if respond_to?(method.to_sym)
+      end
+      return true if protected_methods(include_superclass_methods = true).include?(method)
+      return true if private_methods(include_superclass_methods = true).include?(method)
+      return false
+    end
+  
+  end
+  
+  module ModuleMethods # :nodoc:
+    
+    def stubba_method
+      Mocha::ModuleMethod
+    end
+    
+  end
+  
+  # Methods added all classes to allow mocking and stubbing on real objects.
+  module ClassMethods
+    
+    def stubba_method # :nodoc:
+      Mocha::ClassMethod
+    end
+
+    class AnyInstance # :nodoc:
+    
+      def initialize(klass)
+        @stubba_object = klass
+      end
+    
+      def mocha
+        @mocha ||= Mocha::Mockery.instance.mock_impersonating_any_instance_of(@stubba_object)
+      end
+
+      def stubba_method
+        Mocha::AnyInstanceMethod
+      end
+    
+      def stubba_object
+        @stubba_object
+      end
+    
+      def method_exists?(method, include_public_methods = true)
+        if include_public_methods
+          return true if @stubba_object.public_instance_methods(include_superclass_methods = true).include?(method)
+        end
+        return true if @stubba_object.protected_instance_methods(include_superclass_methods = true).include?(method)
+        return true if @stubba_object.private_instance_methods(include_superclass_methods = true).include?(method)
+        return false
+      end
+    
+    end
+  
+    # :call-seq: any_instance -> mock object
+    #
+    # Returns a mock object which will detect calls to any instance of this class.
+    #   Product.any_instance.stubs(:save).returns(false)
+    #   product_1 = Product.new
+    #   assert_equal false, product_1.save
+    #   product_2 = Product.new
+    #   assert_equal false, product_2.save
+    def any_instance
+      @any_instance ||= AnyInstance.new(self)
+    end
+  
+  end
+  
+end
+
+class Object # :nodoc:
+  include Mocha::ObjectMethods
+end
+
+class Module # :nodoc:
+  include Mocha::ModuleMethods
+end
+
+class Class # :nodoc:
+  include Mocha::ClassMethods
+end

data/lib/mocha/parameter_matchers/all_of.rb

@@ -0,0 +1,42 @@
+require 'mocha/parameter_matchers/base'
+
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: all_of(*parameter_matchers) -> parameter_matcher
+    #
+    # Matches if 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
+    #
+    #   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
+    
+    class AllOf < Base # :nodoc:
+      
+      def initialize(*matchers)
+        @matchers = matchers
+      end
+    
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        @matchers.all? { |matcher| matcher.to_matcher.matches?([parameter]) }
+      end
+      
+      def mocha_inspect
+        "all_of(#{@matchers.map { |matcher| matcher.mocha_inspect }.join(", ") })"
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/mocha/parameter_matchers/any_of.rb

@@ -0,0 +1,47 @@
+require 'mocha/parameter_matchers/base'
+
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: any_of(*parameter_matchers) -> parameter_matcher
+    #
+    # Matches if any +parameter_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)
+    end
+    
+    class AnyOf < Base # :nodoc:
+      
+      def initialize(*matchers)
+        @matchers = matchers
+      end
+    
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        @matchers.any? { |matcher| matcher.to_matcher.matches?([parameter]) }
+      end
+      
+      def mocha_inspect
+        "any_of(#{@matchers.map { |matcher| matcher.mocha_inspect }.join(", ") })"
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/mocha/parameter_matchers/any_parameters.rb

@@ -0,0 +1,40 @@
+require 'mocha/parameter_matchers/base'
+
+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
+    end
+
+    class AnyParameters < Base # :nodoc:
+      
+      def matches?(available_parameters)
+        while available_parameters.length > 0 do
+          available_parameters.shift
+        end
+        return true
+      end
+
+      def mocha_inspect
+        "any_parameters"
+      end
+
+    end
+    
+  end
+  
+end

data/lib/mocha/parameter_matchers/anything.rb

@@ -0,0 +1,33 @@
+require 'mocha/parameter_matchers/base'
+
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: anything() -> parameter_matcher
+    #
+    # Matches any object.
+    #   object = mock()
+    #   object.expects(:method_1).with(anything)
+    #   object.method_1('foo')
+    #   # no error raised
+    def anything
+      Anything.new
+    end
+    
+    class Anything < Base # :nodoc:
+    
+      def matches?(available_parameters)
+        available_parameters.shift
+        return true
+      end
+      
+      def mocha_inspect
+        "anything"
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/mocha/parameter_matchers/base.rb

@@ -0,0 +1,15 @@
+module Mocha
+  
+  module ParameterMatchers
+    
+    class Base # :nodoc:
+      
+      def to_matcher
+        self
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/mocha/parameter_matchers/equals.rb

@@ -0,0 +1,42 @@
+require 'mocha/parameter_matchers/base'
+
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: equals(value) -> parameter_matcher
+    #
+    # Matches +Object+ equalling +value+.
+    #   object = mock()
+    #   object.expects(:method_1).with(equals(2))
+    #   object.method_1(2)
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(equals(2))
+    #   object.method_1(3)
+    #   # error raised, because method_1 was not called with Object equalling 3
+    def equals(value)
+      Equals.new(value)
+    end
+
+    class Equals < Base # :nodoc:
+      
+      def initialize(value)
+        @value = value
+      end
+      
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        parameter == @value
+      end
+      
+      def mocha_inspect
+        @value.mocha_inspect
+      end
+      
+    end
+    
+  end
+  
+end