mocha 0.1

data/lib/mocha/mock_methods.rb

@@ -0,0 +1,55 @@
+require 'mocha/expectation'
+
+module Mocha
+  module MockMethods
+  
+    def expectations
+      @expectations ||= []
+    end
+
+    def expects(symbol)
+      expectations << Expectation.new(symbol)
+      expectations.last
+    end
+
+    def stubs(symbol)
+      expectations << Stub.new(symbol)
+      expectations.last
+    end
+
+    def method_missing(symbol, *arguments, &block)
+      matching_expectation = matching_expectation(symbol, *arguments)
+      if matching_expectation then
+        matching_expectation.invoke
+      else
+        begin
+          super_method_missing(symbol, *arguments, &block)
+    		rescue NoMethodError
+    			unexpected_method_called(symbol, *arguments)
+    		end
+  		end
+  	end
+	
+  	def super_method_missing(symbol, *arguments, &block)
+  	  raise NoMethodError
+    end
+
+  	def unexpected_method_called(symbol, *arguments)
+      MissingExpectation.new(symbol, expectations).with(*arguments).verify
+    end
+	
+  	def matching_expectation(symbol, *arguments)
+      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 }
+    end
+  
+  end
+end

data/lib/mocha/pretty_parameters.rb

@@ -0,0 +1,28 @@
+require 'mocha/inspect'
+
+module Mocha
+
+  class PrettyParameters
+  
+    def initialize(params)
+      @params = params
+      @params_string = params.mocha_inspect
+    end
+  
+    def pretty
+      remove_outer_array_braces!
+      remove_outer_hash_braces!
+      @params_string
+    end
+  
+    def remove_outer_array_braces!
+      @params_string = @params_string.gsub(/^\[|\]$/, '')
+    end
+  
+    def remove_outer_hash_braces!
+      @params_string = @params_string.gsub(/^\{|\}$/, '') if @params.size == 1
+    end
+  
+  end
+  
+end

data/lib/stubba.rb

@@ -0,0 +1,2 @@
+require 'stubba/test_case'
+require 'stubba/object'

data/lib/stubba/any_instance_method.rb

@@ -0,0 +1,31 @@
+require 'stubba/class_method'
+
+module Stubba
+
+  class AnyInstanceMethod < ClassMethod
+  
+    def unstub
+      remove_new_method
+      restore_original_method
+      object.any_instance.reset_mocha
+    end
+   
+    def hide_original_method
+      object.class_eval "alias_method :#{hidden_method}, :#{method}" if object.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"
+    end
+
+    def remove_new_method
+      object.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)
+    end
+
+  end
+  
+end

data/lib/stubba/class_method.rb

@@ -0,0 +1,61 @@
+require 'mocha/metaclass'
+
+module Stubba
+
+  class ClassMethod
+  
+    attr_reader :object, :method
+   
+    def initialize(object, method)
+      @object, @method = object, method
+    end
+  
+    def stub
+      hide_original_method
+      define_new_method
+    end
+  
+    def unstub
+      remove_new_method
+      restore_original_method
+      object.reset_mocha
+    end
+  
+    def hide_original_method
+      object.metaclass.class_eval "alias_method :#{hidden_method}, :#{method}" if object.metaclass.method_defined?(method)
+    end
+  
+    def define_new_method
+      object.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}"
+    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)
+    end
+  
+    def hidden_method
+      "__stubba__#{method.to_s.sub('!', '_exclamation_mark').sub('?', '_question_mark')}__stubba__"
+    end  
+  
+    def cannot_replace_method_error
+      Test::Unit::AssertionFailedError.new("Cannot replace #{method} because it is not defined in #{object}.")
+    end
+  
+    def eql?(other)
+      return false unless (other.class == self.class)
+      (object == other.object) and (method == other.method)
+    end
+  
+    alias_method :==, :eql?
+  
+    def to_s
+      "#{object}.#{method}"
+    end
+
+  end
+  
+end

data/lib/stubba/instance_method.rb

@@ -0,0 +1,22 @@
+require 'stubba/class_method'
+
+module Stubba
+
+  class InstanceMethod < ClassMethod
+   
+    def stub
+      raise cannot_replace_method_error unless exists?
+      define_new_method
+    end
+  
+    def unstub
+      # intentionally empty
+    end
+  
+    def exists?
+      object.respond_to?(method)
+    end
+    
+  end
+  
+end

data/lib/stubba/object.rb

@@ -0,0 +1,77 @@
+require 'mocha/mock'
+require 'stubba/instance_method'
+require 'stubba/class_method'
+require 'stubba/any_instance_method'
+
+class Object
+  
+  def mocha
+    @mocha ||= Mocha::Mock.new
+  end
+  
+  def reset_mocha
+    @mocha = nil
+  end
+  
+  def stubba_method
+    Stubba::InstanceMethod
+  end
+  
+  def stubba_object
+    self
+  end
+
+  def expects(symbol) 
+    method = stubba_method.new(stubba_object, symbol)
+    $stubba.stub(method)
+    mocha.expects(symbol)
+  end
+  
+  def stubs(symbol) 
+    method = stubba_method.new(stubba_object, symbol)
+    $stubba.stub(method)
+    mocha.stubs(symbol)
+  end
+  
+  def verify(*method_names)
+    mocha.verify(*method_names)
+  end
+  
+end
+
+class Module
+  
+  def stubba_method
+    Stubba::ClassMethod
+  end
+    
+end
+  
+class Class
+  
+  def stubba_method
+    Stubba::ClassMethod
+  end
+
+  class AnyInstance
+    
+    def initialize(klass)
+      @stubba_object = klass
+    end
+    
+    def stubba_method
+      Stubba::AnyInstanceMethod
+    end
+    
+    def stubba_object
+      @stubba_object
+    end
+    
+  end
+  
+  def any_instance
+    @any_instance ||= AnyInstance.new(self)
+  end
+  
+end
+

data/lib/stubba/stubba.rb

@@ -0,0 +1,27 @@
+module Stubba
+  
+  class Stubba
+  
+    attr_accessor :stubba_methods
+  
+    def initialize
+      self.stubba_methods = []
+    end
+   
+    def stub(method)
+      unless stubba_methods.include?(method)
+        method.stub 
+        stubba_methods.push method
+      end
+    end
+  
+    def unstub_all
+      while stubba_methods.size > 0
+        method = stubba_methods.pop
+        method.unstub
+      end
+    end
+
+  end
+
+end

data/lib/stubba/test_case.rb

@@ -0,0 +1,65 @@
+require 'stubba/stubba'
+
+class Test::Unit::TestCase
+    
+  def self.method_added(method)
+    # disable until we finish messing about
+  end
+  
+  def setup_with_stubba
+    $stubba = Stubba::Stubba.new
+  end
+  
+  def teardown_with_stubba
+    $stubba.unstub_all
+    $stubba = nil
+  end
+
+  if method_defined?(:setup) then
+    alias_method :setup_pre_stubba, :setup
+    define_method(:setup_post_stubba) do
+      setup_pre_stubba
+      setup_with_stubba
+    end
+  else
+    define_method(:setup_post_stubba) do
+      setup_with_stubba
+    end
+  end  
+  alias_method :setup, :setup_post_stubba
+  
+  if method_defined?(:teardown) then
+    alias_method :teardown_pre_stubba, :teardown
+    define_method(:teardown_post_stubba) do
+      teardown_with_stubba
+      teardown_pre_stubba
+    end
+  else
+    define_method(:teardown_post_stubba) do
+      teardown_with_stubba
+    end
+  end
+  alias_method :teardown, :teardown_post_stubba
+  
+  def self.method_added(method)
+    case method
+    when :setup
+      unless method_defined?(:setup_without_stubba)
+        alias_method :setup_without_stubba, :setup
+        define_method(:setup) do
+          setup_post_stubba
+          setup_without_stubba
+        end
+      end
+    when :teardown
+      unless method_defined?(:teardown_without_stubba)
+        alias_method :teardown_without_stubba, :teardown
+        define_method(:teardown) do
+          teardown_without_stubba
+          teardown_post_stubba
+        end
+      end
+    end
+  end
+
+end

data/test/all_tests.rb

@@ -0,0 +1,100 @@
+require 'test_helper'
+require 'stubba/test_case' # only works if loaded before any derived test cases
+
+require 'test/unit/ui/console/testrunner'
+
+require 'mocha/inspect_test'
+require 'mocha/pretty_parameters_test'
+require 'mocha/expectation_test'
+require 'mocha/infinite_range_test'
+require 'mocha/mock_methods_test'
+require 'mocha/mock_test'
+
+class MochaUnitTests
+  
+  def self.suite
+    suite = Test::Unit::TestSuite.new('MochaUnitTests')
+    suite << InspectTest.suite
+    suite << PrettyParametersTest.suite
+    suite << ExpectationTest.suite
+    suite << InfiniteRangeTest.suite
+    suite << MockMethodsTest.suite
+    suite << MockTest.suite
+    suite
+  end
+  
+end
+
+Test::Unit::UI::Console::TestRunner.run(MochaUnitTests)
+
+require 'auto_mocha/mock_class_test'
+require 'auto_mocha/auto_mock_test'
+
+class AutoMochaUnitTests
+  
+  def self.suite
+    suite = Test::Unit::TestSuite.new('AutoMochaUnitTests')
+    suite << AutoMockTest.suite
+    suite << MockClassTest.suite
+  end
+  
+end
+
+Test::Unit::UI::Console::TestRunner.run(AutoMochaUnitTests)
+
+require 'stubba/stubba_test'
+require 'stubba/class_method_test'
+require 'stubba/instance_method_test'
+require 'stubba/any_instance_method_test'
+require 'stubba/test_case_test'
+
+class StubbaUnitTests
+  
+  def self.suite
+    suite = Test::Unit::TestSuite.new('StubbaUnitTests')
+    suite << StubbaTest.suite
+    suite << ClassMethodTest.suite
+    suite << InstanceMethodTest.suite
+    suite << AnyInstanceMethodTest.suite
+    suite << TestCaseTest.suite
+    suite
+  end
+  
+end
+
+Test::Unit::UI::Console::TestRunner.run(StubbaUnitTests)
+
+require 'stubba/object_test'
+
+class IsolatedStubbaUnitTests # avoid loading stubba_object until now which breaks other stubba unit tests
+  
+  def self.suite
+    suite = Test::Unit::TestSuite.new('IsolatedStubbaUnitTests')
+    suite << ObjectTest.suite
+    suite
+  end
+  
+end
+
+Test::Unit::UI::Console::TestRunner.run(IsolatedStubbaUnitTests)
+
+require 'stubba_integration_test'
+Test::Unit::UI::Console::TestRunner.run(StubbaIntegrationTest)
+
+require 'mocha_acceptance_test'
+require 'stubba_acceptance_test'
+require 'auto_mock_acceptance_test'
+
+class AcceptanceTests
+  
+  def self.suite
+    suite = Test::Unit::TestSuite.new('AcceptanceTests')
+    suite << MochaAcceptanceTest.suite
+    suite << StubbaAcceptanceTest.suite
+    suite << AutoMockAcceptanceTest.suite
+    suite
+  end
+  
+end
+
+Test::Unit::UI::Console::TestRunner.run(AcceptanceTests)