mocha-macruby 0.9.8.20100129120100

data/lib/mocha/integration/test_unit/ruby_version_185_and_below.rb

@@ -0,0 +1,48 @@
+require 'test/unit/testcase'
+require 'mocha/integration/test_unit/assertion_counter'
+require 'mocha/expectation_error'
+
+module Mocha
+  
+  module Integration
+    
+    module TestUnit
+      
+      module RubyVersion185AndBelow
+        def run(result)
+          assertion_counter = AssertionCounter.new(result)
+          yield(Test::Unit::TestCase::STARTED, name)
+          @_result = result
+          begin
+            begin
+              setup
+              __send__(@method_name)
+              mocha_verify(assertion_counter)
+            rescue Mocha::ExpectationError => e
+              add_failure(e.message, e.backtrace)
+            rescue Test::Unit::AssertionFailedError => e
+              add_failure(e.message, e.backtrace)
+            rescue StandardError, ScriptError
+              add_error($!)
+            ensure
+              begin
+                teardown
+              rescue Test::Unit::AssertionFailedError => e
+                add_failure(e.message, e.backtrace)
+              rescue StandardError, ScriptError
+                add_error($!)
+              end
+            end
+          ensure
+            mocha_teardown
+          end
+          result.add_run
+          yield(Test::Unit::TestCase::FINISHED, name)
+        end
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/mocha/integration/test_unit/ruby_version_186_and_above.rb

@@ -0,0 +1,50 @@
+require 'test/unit/testcase'
+require 'mocha/integration/test_unit/assertion_counter'
+require 'mocha/expectation_error'
+
+module Mocha
+  
+  module Integration
+    
+    module TestUnit
+      
+      module RubyVersion186AndAbove
+        def run(result)
+          assertion_counter = AssertionCounter.new(result)
+          yield(Test::Unit::TestCase::STARTED, name)
+          @_result = result
+          begin
+            begin
+              setup
+              __send__(@method_name)
+              mocha_verify(assertion_counter)
+            rescue Mocha::ExpectationError => e
+              add_failure(e.message, e.backtrace)
+            rescue Test::Unit::AssertionFailedError => e
+              add_failure(e.message, e.backtrace)
+            rescue Exception
+              raise if Test::Unit::TestCase::PASSTHROUGH_EXCEPTIONS.include? $!.class
+              add_error($!)
+            ensure
+              begin
+                teardown
+              rescue Test::Unit::AssertionFailedError => e
+                add_failure(e.message, e.backtrace)
+              rescue Exception
+                raise if Test::Unit::TestCase::PASSTHROUGH_EXCEPTIONS.include? $!.class
+                add_error($!)
+              end
+            end
+          ensure
+            mocha_teardown
+          end
+          result.add_run
+          yield(Test::Unit::TestCase::FINISHED, name)
+        end
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/mocha/is_a.rb

@@ -0,0 +1,9 @@
+class Object
+
+  # :stopdoc:
+
+  alias_method :__is_a__, :is_a?
+
+  # :startdoc:
+  
+end

data/lib/mocha/logger.rb

@@ -0,0 +1,15 @@
+module Mocha
+  
+  class Logger
+    
+    def initialize(io)
+      @io = io
+    end
+    
+    def warn(message)
+      @io.puts "WARNING: #{message}"
+    end
+    
+  end
+  
+end

data/lib/mocha/metaclass.rb

@@ -0,0 +1,13 @@
+module Mocha
+  
+  module ObjectMethods
+    def __metaclass__
+      class << self; self; end
+    end
+  end
+  
+end
+
+class Object
+  include Mocha::ObjectMethods
+end

data/lib/mocha/method_matcher.rb

@@ -0,0 +1,21 @@
+module Mocha
+  
+  class MethodMatcher
+    
+    attr_reader :expected_method_name
+    
+    def initialize(expected_method_name)
+      @expected_method_name = expected_method_name
+    end
+    
+    def match?(actual_method_name)
+      @expected_method_name == actual_method_name
+    end
+    
+    def mocha_inspect
+      "#{@expected_method_name}"
+    end
+    
+  end
+
+end

data/lib/mocha/mock.rb

@@ -0,0 +1,200 @@
+require 'mocha/expectation'
+require 'mocha/expectation_list'
+require 'mocha/metaclass'
+require 'mocha/names'
+require 'mocha/mockery'
+require 'mocha/method_matcher'
+require 'mocha/parameters_matcher'
+require 'mocha/unexpected_invocation'
+require 'mocha/argument_iterator'
+
+module Mocha # :nodoc:
+  
+  # Traditional mock object.
+  #
+  # Methods return an Expectation which can be further modified by methods on Expectation.
+  class Mock
+    
+    # :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/String must be called exactly once with any parameters.
+    # Returns the new expectation which can be further modified by methods on Expectation.
+    #   object = mock()
+    #   object.expects(:method1)
+    #   object.method1
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method1)
+    #   # error raised, because method1 not called exactly once
+    # 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+.
+    #   object = mock()
+    #   object.expects(:method1 => :result1, :method2 => :result2)
+    #
+    #   # exactly equivalent to
+    #
+    #   object = mock()
+    #   object.expects(:method1).returns(:result1)
+    #   object.expects(:method2).returns(:result2)
+    #
+    # Aliased by <tt>\_\_expects\_\_</tt>
+    def expects(method_name_or_hash, backtrace = nil)
+      iterator = ArgumentIterator.new(method_name_or_hash)
+      iterator.each { |*args|
+        method_name = args.shift
+        ensure_method_not_already_defined(method_name)
+        expectation = Expectation.new(self, method_name, backtrace)
+        expectation.returns(args.shift) if args.length > 0
+        @expectations.add(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/String may be called any number of times with any parameters.
+    # Returns the new expectation which can be further modified by methods on Expectation.
+    #   object = mock()
+    #   object.stubs(:method1)
+    #   object.method1
+    #   object.method1
+    #   # no error raised
+    # 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+.
+    #   object = mock()
+    #   object.stubs(:method1 => :result1, :method2 => :result2)
+    #
+    #   # exactly equivalent to
+    #
+    #   object = mock()
+    #   object.stubs(:method1).returns(:result1)
+    #   object.stubs(:method2).returns(:result2)
+    #
+    # Aliased by <tt>\_\_stubs\_\_</tt>
+    def stubs(method_name_or_hash, backtrace = nil)
+      iterator = ArgumentIterator.new(method_name_or_hash)
+      iterator.each { |*args|
+        method_name = args.shift
+        ensure_method_not_already_defined(method_name)
+        expectation = Expectation.new(self, method_name, backtrace)
+        expectation.at_least(0)
+        expectation.returns(args.shift) if args.length > 0
+        @expectations.add(expectation)
+      }
+    end
+    
+    # :call-seq: responds_like(responder) -> mock
+    #
+    # Constrains the +mock+ so that it can only expect or stub methods to which +responder+ responds. The constraint is only applied at method invocation time.
+    #
+    # A +NoMethodError+ will be raised if the +responder+ does not <tt>respond_to?</tt> a method invocation (even if the method has been expected or stubbed).
+    #
+    # The +mock+ will delegate its <tt>respond_to?</tt> method to the +responder+.
+    #   class Sheep
+    #     def chew(grass); end
+    #     def self.number_of_legs; end
+    #   end
+    #
+    #   sheep = mock('sheep')
+    #   sheep.expects(:chew)
+    #   sheep.expects(:foo)
+    #   sheep.respond_to?(:chew) # => true
+    #   sheep.respond_to?(:foo) # => true
+    #   sheep.chew
+    #   sheep.foo
+    #   # no error raised
+    #
+    #   sheep = mock('sheep')
+    #   sheep.responds_like(Sheep.new)
+    #   sheep.expects(:chew)
+    #   sheep.expects(:foo)
+    #   sheep.respond_to?(:chew) # => true
+    #   sheep.respond_to?(:foo) # => false
+    #   sheep.chew
+    #   sheep.foo # => raises NoMethodError exception
+    #
+    #   sheep_class = mock('sheep_class')
+    #   sheep_class.responds_like(Sheep)
+    #   sheep_class.stubs(:number_of_legs).returns(4)
+    #   sheep_class.expects(:foo)
+    #   sheep_class.respond_to?(:number_of_legs) # => true
+    #   sheep_class.respond_to?(:foo) # => false
+    #   assert_equal 4, sheep_class.number_of_legs
+    #   sheep_class.foo # => raises NoMethodError exception
+    #
+    # Aliased by +quacks_like+
+    def responds_like(object)
+      @responder = object
+      self
+    end
+    
+    # :stopdoc:
+    
+    def initialize(name = nil, &block)
+      @name = name || DefaultName.new(self)
+      @expectations = ExpectationList.new
+      @everything_stubbed = false
+      @responder = nil
+      instance_eval(&block) if block
+    end
+
+    attr_reader :everything_stubbed, :expectations
+
+    alias_method :__expects__, :expects
+
+    alias_method :__stubs__, :stubs
+    
+    alias_method :quacks_like, :responds_like
+
+    def stub_everything
+      @everything_stubbed = true
+    end
+    
+    def method_missing(symbol, *arguments, &block)
+      if @responder and not @responder.respond_to?(symbol)
+        raise NoMethodError, "undefined method `#{symbol}' for #{self.mocha_inspect} which responds like #{@responder.mocha_inspect}"
+      end
+      if matching_expectation_allowing_invocation = @expectations.match_allowing_invocation(symbol, *arguments)
+        matching_expectation_allowing_invocation.invoke(&block)
+      else
+        if (matching_expectation = @expectations.match(symbol, *arguments)) || (!matching_expectation && !@everything_stubbed)
+          message = UnexpectedInvocation.new(self, symbol, *arguments).to_s
+          message << Mockery.instance.mocha_inspect
+          raise ExpectationError.new(message, caller)
+        end
+      end
+    end
+    
+    def respond_to?(symbol, include_private = false)
+      if @responder then
+        if @responder.method(:respond_to?).arity > 1
+          @responder.respond_to?(symbol, include_private)
+        else
+          @responder.respond_to?(symbol)
+        end
+      else
+        @everything_stubbed || @expectations.matches_method?(symbol)
+      end
+    end
+    
+    def __verified__?(assertion_counter = nil)
+      @expectations.verified?(assertion_counter)
+    end
+    
+    def mocha_inspect
+      @name.mocha_inspect
+    end
+    
+    def inspect
+      mocha_inspect
+    end
+    
+    def ensure_method_not_already_defined(method_name)
+      self.__metaclass__.send(:undef_method, method_name) if self.__metaclass__.method_defined?(method_name)
+    end
+
+    # :startdoc:
+
+  end
+
+end

data/lib/mocha/mockery.rb

@@ -0,0 +1,181 @@
+require 'mocha/central'
+require 'mocha/mock'
+require 'mocha/names'
+require 'mocha/state_machine'
+require 'mocha/logger'
+require 'mocha/configuration'
+require 'mocha/stubbing_error'
+
+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 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
+    
+    
+    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