mocha 0.2.1 → 0.3.0

data/README

@@ -20,6 +20,10 @@ Mocha and Stubba have been created by amalgamating a number of techniques develo
 You can download Mocha from here[http://rubyforge.org/projects/mocha] or install it with the following command.
 
  $ gem install mocha
+ 
+== Ruby on Rails plugin
+
+  $ script/plugin install svn://rubyforge.org/var/svn/mocha/trunk
 
 == License
 
@@ -45,9 +49,9 @@ See MochaAcceptanceTest, StubbaAcceptanceTest, AutoMochaAcceptanceTest and unit
 
   end
 
+  require 'test/unit'
   require 'rubygems'
   require 'mocha'
-  require 'test/unit'
 
   class EnterpriseTest < Test::Unit::TestCase
 
@@ -96,9 +100,9 @@ See MochaAcceptanceTest, StubbaAcceptanceTest, AutoMochaAcceptanceTest and unit
 
   end
 
+  require 'test/unit'
   require 'rubygems'
   require 'stubba'
-  require 'test/unit'
 
   class OrderTest < Test::Unit::TestCase
 

data/RELEASE

@@ -1,3 +1,14 @@
+= 0.3.0
+
+* Rails plugin.
+* Auto-verify for expectations on concrete classes.
+* Include each expectation verification in the test result assertion count.
+* Filter out noise from assertion backtraces.
+* Point assertion backtrace to line where failing expectation was created.
+* New yields method for expectations.
+* Create stubs which stub all method calls.
+* Mocks now respond_to? expected methods.
+
 = 0.2.1
 
 * Rename MochaAcceptanceTest::Rover#move method to avoid conflict with Rake (in Ruby 1.8.4 only?)

data/Rakefile

@@ -47,7 +47,7 @@ Gem::manage_gems
 specification = Gem::Specification.new do |s|
 	s.name   = "mocha"
   s.summary = "Mocking and stubbing library"
-	s.version = "0.2.1"
+	s.version = "0.3.0"
 	s.author = 'James Mead'
 	s.description = <<-EOF
     Mocking and stubbing library with JMock/SchMock syntax, which allows mocking and stubbing of methods on real (non-mock) classes.

data/TODO

@@ -1,15 +1,13 @@
+- think about behaviour when more than one expectation/stubbed method match
 - make verify method private (makes this unnecessary - fail if attempt to verify stub)
-- auto-verify for stubs?
 - allow hash parameter for stubs and expects methods particularly for stubba
 - write rdoc for most important methods/classes e.g. expectation
-- remove mocha/stubba from call stack when assertion error raised
 - test for setting expectations on class methods (and instance methods?) from within TestCase#setup
 - use Object#inspect(:mocha) instead of Object#mocha_inspect?
 - allow stubbing of private/protected methods?
 - should all instances share expectations for any_instance or should each instance have their own - in which case how do we provide access to the instances
 - detect existing or added definition of mocha methods e.g. expects and alias to __expects?
 - allow switch off of auto-verify?
-- fail if verify called with no expectations? set expectation - expects(:blah).never to ensure method not called
 - maybe use blank_slate as mocha parent class to allow mocking of standard object methods?
 - more jmock style stuff - e.g. return values on consecutive calls, labels/required order, more sophisticated param matching?
 - stubs should only return a fixed value - no blocks allowed for return values and no parameter expectations allowed?

data/lib/mocha.rb

@@ -1,5 +1,6 @@
 require 'smart_test_case'
 require 'mocha/auto_verify'
+require 'shared/backtracefilter'
 
 class Test::Unit::TestCase
   include AutoVerify unless ancestors.include?(AutoVerify)

data/lib/mocha/auto_verify.rb

@@ -15,27 +15,32 @@ module AutoVerify
   end
 
   def mock(expectations = {})
-    mock = Mocha::Mock.new
-    expectations.each do |method, result|
-      mock.expects(method).returns(result)
-    end
-    mocks << mock
-    mock
+    build_mock_with_expectations(:expects, expectations)
   end
   
   def stub(expectations = {})
-    mock = Mocha::Mock.new
-    expectations.each do |method, result|
-      mock.stubs(method).returns(result)
-    end
-    mocks << mock
-    mock
+    build_mock_with_expectations(:stubs, expectations)
+  end
+  
+  def stub_everything(expectations = {})
+    build_mock_with_expectations(:stub_everything, expectations)
   end
 
   def teardown_mocks
-    mocks.each { |mock| mock.verify }
+    mocks.each { |mock| mock.verify { add_assertion } }
     reset_mocks
   end
   
+  def build_mock_with_expectations(expectation_type = :expects, expectations = {})
+    stub_everything = (expectation_type == :stub_everything)
+    expectation_type = :stubs if expectation_type == :stub_everything
+    mock = Mocha::Mock.new(stub_everything)
+    expectations.each do |method, result|
+      mock.send(expectation_type, method).returns(result)
+    end
+    mocks << mock
+    mock
+  end
+  
 end
 

data/lib/mocha/expectation.rb

@@ -15,13 +15,18 @@ module Mocha
       end
     end
   
-    attr_reader :method_name
+    attr_reader :method_name, :backtrace
 
-    def initialize(method_name)
+    def initialize(method_name, backtrace = nil)
       @method_name = method_name
       @count = 1
       @parameters, @parameter_block = AlwaysEqual.new, nil
       @invoked, @return_value = 0, nil
+      @backtrace = backtrace || caller
+    end
+    
+    def yield?
+      @yield
     end
 
     def match?(method_name, *arguments)
@@ -57,6 +62,12 @@ module Mocha
       self
     end
   
+    def yields(*parameters)
+      @yield = true
+      @parameters_to_yield = parameters
+      self
+    end
+
     def returns(value)
       @return_value = value
       self
@@ -69,12 +80,16 @@ module Mocha
 
     def invoke
       @invoked += 1
+      yield(*@parameters_to_yield) if yield? and block_given?
       @return_value.is_a?(Proc) ? @return_value.call : @return_value
     end
 
     def verify
+      yield(self) if block_given?
       unless (@count === @invoked) then
-        raise Test::Unit::AssertionFailedError, "#{message}: expected calls: #{@count}, actual calls: #{@invoked}"
+        failure = Test::Unit::AssertionFailedError.new("#{message}: expected calls: #{@count}, actual calls: #{@invoked}")
+        failure.set_backtrace(backtrace)
+        raise failure
       end
     end
   

data/lib/mocha/mock.rb

@@ -1,30 +1,13 @@
 require 'mocha/mock_methods'
-require 'test/unit/assertions'
 
 module Mocha
   class Mock
   
     include MockMethods
   
-    attr_reader :mocked
-  
-    def initialize(*arguments)
-      @mocked = arguments.shift unless arguments.first.is_a?(Hash)
-      @mocked ||= always_responds
-      expectations = arguments.shift || {}
-      expectations.each do |method_name, result|
-        expects(method_name).returns(result)
-      end
-    end
-  
-    def expects(symbol)
-      raise Test::Unit::AssertionFailedError, "Cannot replace #{symbol} as #{@mocked} does not respond to it." unless @mocked.respond_to?(symbol)
-      super
+    def initialize(stub_everything = false)
+      @stub_everything = stub_everything
     end
   
-    def always_responds
-      Class.new { def respond_to?(symbol); true; end }.new
-    end
-
   end
 end

data/lib/mocha/mock_methods.rb

@@ -2,25 +2,29 @@ require 'mocha/expectation'
 
 module Mocha
   module MockMethods
+    
+    attr_reader :stub_everything
   
     def expectations
       @expectations ||= []
     end
 
-    def expects(symbol)
-      expectations << Expectation.new(symbol)
+    def expects(symbol, backtrace = nil)
+      expectations << Expectation.new(symbol, backtrace)
       expectations.last
     end
 
-    def stubs(symbol)
-      expectations << Stub.new(symbol)
+    def stubs(symbol, backtrace = nil)
+      expectations << Stub.new(symbol, backtrace)
       expectations.last
     end
-
+    
     def method_missing(symbol, *arguments, &block)
       matching_expectation = matching_expectation(symbol, *arguments)
       if matching_expectation then
-        matching_expectation.invoke
+        matching_expectation.invoke(&block)
+      elsif stub_everything then
+        return
       else
         begin
           super_method_missing(symbol, *arguments, &block)
@@ -29,6 +33,10 @@ module Mocha
     		end
   		end
   	end
+  	
+  	def respond_to?(symbol)
+  	  expectations.any? { |expectation| expectation.method_name == symbol }
+	  end
 	
   	def super_method_missing(symbol, *arguments, &block)
   	  raise NoMethodError
@@ -42,13 +50,8 @@ module Mocha
       expectations.detect { |expectation| expectation.match?(symbol, *arguments) }
     end
   
-    def expectations_matching(method_names)
-      expectations.select { |expectation| method_names.include?(expectation.method_name) }
-    end
-
-    def verify(*method_names)
-      for_verification = method_names.empty? ? expectations : expectations_matching(method_names)
-      for_verification.each { |expectation| expectation.verify }
+    def verify(&block)
+      expectations.each { |expectation| expectation.verify(&block) }
     end
   
   end

data/lib/shared/backtracefilter.rb

@@ -0,0 +1,46 @@
+module Test
+  module Unit
+    module Util
+      module BacktraceFilter
+        
+        # quick rip-off of Test::Unit code - there must be a better way of doing this!
+        
+        MOCHA_FILE_SEPARATORS = %r{[\\/:]}
+        MOCHA_PREFIX = __FILE__.split(MOCHA_FILE_SEPARATORS)[0..-3]
+        MOCHA_RB_FILE = /\.rb\Z/
+        
+        alias_method :__filter_backtrace__, :filter_backtrace
+        
+        def filter_backtrace(backtrace, prefix=nil)
+          backtrace = __filter_backtrace__(backtrace, prefix)
+          return ["No backtrace"] unless(backtrace)
+          split_p = if(prefix)
+            prefix.split(MOCHA_FILE_SEPARATORS)
+          else
+            MOCHA_PREFIX
+          end
+          match = proc do |e|
+            split_e = e.split(MOCHA_FILE_SEPARATORS)[0, split_p.size]
+            next false unless(split_e[0..-2] == split_p[0..-2])
+            split_e[-1].sub(MOCHA_RB_FILE, '') == split_p[-1]
+          end
+          return backtrace unless(backtrace.detect(&match))
+          found_prefix = false
+          new_backtrace = backtrace.reverse.reject do |e|
+            if(match[e])
+              found_prefix = true
+              true
+            elsif(found_prefix)
+              false
+            else
+              true
+            end
+          end.reverse
+          new_backtrace = (new_backtrace.empty? ? backtrace : new_backtrace)
+          new_backtrace = new_backtrace.reject(&match)
+          new_backtrace.empty? ? backtrace : new_backtrace
+        end
+      end
+    end
+  end
+end

data/lib/smart_test_case/multiple_setup_and_teardown.rb

@@ -105,7 +105,15 @@ module MultipleSetupAndTeardown
       end
 
       def teardown_mocha
-        self.class.class_eval { teardown_methods }.reverse.each { |symbol| send(symbol) }
+        stored_exception = nil
+        self.class.class_eval { teardown_methods }.reverse.each do |symbol|
+          begin
+            send(symbol)
+          rescue Exception => e
+            stored_exception ||= e
+          end
+        end
+        raise stored_exception if stored_exception
       end
 
     end

data/lib/stubba.rb

@@ -1,6 +1,7 @@
 require 'stubba/object'
 require 'smart_test_case'
 require 'stubba/setup_and_teardown'
+require 'shared/backtracefilter'
 
 class Test::Unit::TestCase
   include SetupAndTeardown unless ancestors.include?(SetupAndTeardown)

data/lib/stubba/any_instance_method.rb

@@ -7,23 +7,27 @@ module Stubba
     def unstub
       remove_new_method
       restore_original_method
-      object.any_instance.reset_mocha
+      stubbee.any_instance.reset_mocha
+    end
+    
+    def mock
+      stubbee.any_instance.mocha
     end
    
     def hide_original_method
-      object.class_eval "alias_method :#{hidden_method}, :#{method}" if object.method_defined?(method)
+      stubbee.class_eval "alias_method :#{hidden_method}, :#{method}" if stubbee.method_defined?(method)
     end
 
     def define_new_method
-      object.class_eval "def #{method}(*args, &block); self.class.any_instance.mocha.method_missing(:#{method}, *args, &block); end"
+      stubbee.class_eval "def #{method}(*args, &block); self.class.any_instance.mocha.method_missing(:#{method}, *args, &block); end"
     end
 
     def remove_new_method
-      object.class_eval "remove_method :#{method}"
+      stubbee.class_eval "remove_method :#{method}"
     end
 
     def restore_original_method
-      object.class_eval "alias_method :#{method}, :#{hidden_method}; remove_method :#{hidden_method}" if object.method_defined?(hidden_method)
+      stubbee.class_eval "alias_method :#{method}, :#{hidden_method}; remove_method :#{hidden_method}" if stubbee.method_defined?(hidden_method)
     end
 
   end

data/lib/stubba/central.rb

@@ -14,6 +14,14 @@ module Stubba
         stubba_methods.push method
       end
     end
+    
+    def verify_all(&block)
+      unique_mocks.each { |mock| mock.verify(&block) }
+    end
+    
+    def unique_mocks
+      stubba_methods.collect { |method| method.mock }.uniq
+    end
   
     def unstub_all
       while stubba_methods.size > 0

data/lib/stubba/class_method.rb

@@ -4,10 +4,10 @@ module Stubba
 
   class ClassMethod
   
-    attr_reader :object, :method
+    attr_reader :stubbee, :method
    
-    def initialize(object, method)
-      @object, @method = object, method
+    def initialize(stubbee, method)
+      @stubbee, @method = stubbee, method
     end
   
     def stub
@@ -18,23 +18,27 @@ module Stubba
     def unstub
       remove_new_method
       restore_original_method
-      object.reset_mocha
+      stubbee.reset_mocha
+    end
+    
+    def mock
+      stubbee.mocha
     end
   
     def hide_original_method
-      object.metaclass.class_eval "alias_method :#{hidden_method}, :#{method}" if object.metaclass.method_defined?(method)
+      stubbee.metaclass.class_eval "alias_method :#{hidden_method}, :#{method}" if stubbee.metaclass.method_defined?(method)
     end
   
     def define_new_method
-      object.metaclass.class_eval "def #{method}(*args, &block); mocha.method_missing(:#{method}, *args, &block); end"
+      stubbee.metaclass.class_eval "def #{method}(*args, &block); mocha.method_missing(:#{method}, *args, &block); end"
     end
   
     def remove_new_method
-      object.metaclass.class_eval "remove_method :#{method}"
+      stubbee.metaclass.class_eval "remove_method :#{method}"
     end
   
     def restore_original_method
-      object.metaclass.class_eval "alias_method :#{method}, :#{hidden_method}; remove_method :#{hidden_method}" if object.metaclass.method_defined?(hidden_method)
+      stubbee.metaclass.class_eval "alias_method :#{method}, :#{hidden_method}; remove_method :#{hidden_method}" if stubbee.metaclass.method_defined?(hidden_method)
     end
   
     def hidden_method
@@ -42,18 +46,18 @@ module Stubba
     end  
   
     def cannot_replace_method_error
-      Test::Unit::AssertionFailedError.new("Cannot replace #{method} because it is not defined in #{object}.")
+      Test::Unit::AssertionFailedError.new("Cannot replace #{method} because it is not defined in #{stubbee}.")
     end
   
     def eql?(other)
       return false unless (other.class == self.class)
-      (object == other.object) and (method == other.method)
+      (stubbee == other.stubbee) and (method == other.method)
     end
   
     alias_method :==, :eql?
   
     def to_s
-      "#{object}.#{method}"
+      "#{stubbee}.#{method}"
     end
 
   end