thewoolleyman-mocha 0.9.3.20081219131457

data/lib/mocha/expectation_error.rb

@@ -0,0 +1,15 @@
+require 'mocha/backtrace_filter'
+
+module Mocha
+
+  class ExpectationError < StandardError
+    
+    def initialize(message = nil, backtrace = [])
+      super(message)
+      filter = BacktraceFilter.new
+      set_backtrace(filter.filtered(backtrace))
+    end
+
+  end
+  
+end

data/lib/mocha/expectation_list.rb

@@ -0,0 +1,50 @@
+module Mocha # :nodoc:
+
+  class ExpectationList
+
+    def initialize
+      @expectations = []
+    end
+    
+    def add(expectation)
+      @expectations.unshift(expectation)
+      expectation
+    end
+    
+    def matches_method?(method_name)
+      @expectations.any? { |expectation| expectation.matches_method?(method_name) }
+    end
+    
+    def match(method_name, *arguments)
+      matching_expectations(method_name, *arguments).first
+    end
+    
+    def match_allowing_invocation(method_name, *arguments)
+      matching_expectations(method_name, *arguments).detect { |e| e.invocations_allowed? }
+    end
+    
+    def verified?(assertion_counter = nil)
+      @expectations.all? { |expectation| expectation.verified?(assertion_counter) }
+    end
+    
+    def to_a
+      @expectations
+    end
+    
+    def to_set
+      @expectations.to_set
+    end
+    
+    def length
+      @expectations.length
+    end
+    
+    private
+    
+    def matching_expectations(method_name, *arguments)
+      @expectations.select { |e| e.match?(method_name, *arguments) }
+    end
+    
+  end
+
+end

data/lib/mocha/in_state_ordering_constraint.rb

@@ -0,0 +1,19 @@
+module Mocha
+
+  class InStateOrderingConstraint
+  
+    def initialize(state_predicate)
+      @state_predicate = state_predicate
+    end
+  
+    def allows_invocation_now?
+      @state_predicate.active?
+    end
+  
+    def mocha_inspect
+      "when #{@state_predicate.mocha_inspect}"
+    end
+  
+  end
+
+end

data/lib/mocha/inspect.rb

@@ -0,0 +1,67 @@
+require 'date'
+
+module Mocha
+  
+  module ObjectMethods
+    def mocha_inspect
+      address = self.__id__ * 2
+      address += 0x100000000 if address < 0
+      inspect =~ /#</ ? "#<#{self.class}:0x#{'%x' % address}>" : inspect
+    end
+  end
+  
+  module StringMethods
+    def mocha_inspect
+      inspect.gsub(/\"/, "'")
+    end
+  end
+  
+  module ArrayMethods
+    def mocha_inspect
+      "[#{collect { |member| member.mocha_inspect }.join(', ')}]"
+    end
+  end
+  
+  module HashMethods
+    def mocha_inspect
+      "{#{collect { |key, value| "#{key.mocha_inspect} => #{value.mocha_inspect}" }.join(', ')}}"
+    end
+  end
+  
+  module TimeMethods
+    def mocha_inspect
+      "#{inspect} (#{to_f} secs)"
+    end
+  end
+  
+  module DateMethods
+    def mocha_inspect
+      to_s
+    end
+  end
+  
+end
+
+class Object
+  include Mocha::ObjectMethods
+end
+
+class String
+  include Mocha::StringMethods
+end
+
+class Array
+  include Mocha::ArrayMethods
+end
+
+class Hash
+  include Mocha::HashMethods
+end
+
+class Time
+  include Mocha::TimeMethods
+end
+
+class Date
+  include Mocha::DateMethods
+end

data/lib/mocha/instance_method.rb

@@ -0,0 +1,16 @@
+require 'mocha/class_method'
+
+module Mocha
+
+  class InstanceMethod < 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/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/mini_test_adapter.rb

@@ -0,0 +1,50 @@
+module Mocha
+
+  module MiniTestCaseAdapter
+
+    class AssertionCounter
+      def initialize(test_case)
+        @test_case = test_case
+      end
+
+      def increment
+        @test_case._assertions += 1
+      end
+    end
+
+    def self.included(base)
+      base.class_eval do
+
+        alias_method :run_before_mocha_mini_test_adapter, :run
+
+        def run runner
+          assertion_counter = AssertionCounter.new(self)
+          result = '.'
+          begin
+            begin
+              @passed = nil
+              self.setup
+              self.__send__ self.name
+              mocha_verify(assertion_counter)
+              @passed = true
+            rescue Exception => e
+              @passed = false
+              result = runner.puke(self.class, self.name, e)
+            ensure
+              begin
+                self.teardown
+              rescue Exception => e
+                result = runner.puke(self.class, self.name, e)
+              end
+            end
+          ensure
+            mocha_teardown
+          end
+          result
+        end
+
+      end
+    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
+        @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