mocha 0.1

data/COPYING

@@ -0,0 +1,3 @@
+Copyright Revieworld Ltd. 2006
+ 	
+You may use, copy and redistribute this library under the same terms as Ruby itself (see http://www.ruby-lang.org/en/LICENSE.txt).

data/README

@@ -0,0 +1,148 @@
+= Mocha
+
+Mocha is a library for mocking and stubbing with unit tests using a syntax like that of JMock[http://www.jmock.org] and SchMock[http://rubyforge.org/projects/schmock].
+
+Mocha comes in three parts:
+
+  1. Mocha - traditional mock objects with expectations and verification
+  2. Stubba - allows mocking and stubbing of methods on real (non-mock) classes
+  3. AutoMocha - magically provides mocks in the place of undefined classes
+
+Stubba & AutoMocha are the main difference between this mocking library and others like FlexMock[http://onestepback.org/software/flexmock] and RSpec[http://rspec.rubyforge.org].
+
+== Provenance
+
+Mocha & Stubba have been created by amalgamating a number of techniques developed by my Reevoo[http://www.reevoo.com] colleagues (Ben[http://www.reevoo.com/blogs/bengriffiths/], Chris[http://blog.seagul.co.uk] & Paul[http://po-ru.com]) and I[http:blog.floehopper.org] under a common syntax. They are both in use on real-world projects using {Ruby On Rails}[http://www.rubyonrails.org]. AutoMocha is more experimental and is at an earlier stage of development.
+
+== Download & Installation
+
+You can download Mocha from here[http://rubyforge.org/projects/mocha] or install Mocha with the following command.
+
+ $ gem install flexmock
+
+== License
+
+Copyright Revieworld Ltd. 2006
+ 	
+You may use, copy and redistribute this library under the same terms as Ruby itself (see http://www.ruby-lang.org/en/LICENSE.txt).
+
+== Simple Mocha Example
+
+  class Enterprise
+
+    def initialize(dilithium)
+      @dilithium = dilithium
+    end
+
+    def go(warp_factor)
+      warp_factor.times { @dilithium.nuke(:anti_matter) }
+    end
+
+  end
+
+  require 'mocha'
+
+  class EnterpriseTest < Test::Unit::TestCase
+
+    include Mocha
+
+    def test_should_boldly_go
+      dilithium = Mock.new
+      dilithium.expects(:nuke).with(:anti_matter).at_least_once
+      enterprise = Enterprise.new(dilithium)
+      enterprise.go(2)
+      dilithium.verify
+    end
+
+  end
+
+== Simple Stubba Example
+
+  class Order
+
+    def total_cost
+      line_items.inject(0) { |total, line_item| total + line_item.price } + shipping_cost
+    end
+
+    def total_weight
+      line_items.inject(0) { |total, line_item| total + line_item.weight }
+    end
+
+    def shipping_cost
+      total_weight * 5 + 10
+    end
+  
+    class << self
+
+	    def find_all
+	      Database.connection.select_all('select * from orders')
+	    end
+
+	    def number_shipped_since(date)
+	      find_all.select { |order| order.shipped_on > date }.size
+	    end
+	
+	    def unshipped_value
+	      find_all.inject(0) { |order| order.shipped_on ? 0 : order.total_cost }
+	    end
+	
+	  end
+  end
+
+  require 'stubba'
+
+  class OrderTest < Test::Unit::TestCase
+
+    # illustrates stubbing instance method
+    def test_should_calculate_shipping_cost_based_on_total_weight
+	    order = Order.new
+	    order.stubs(:total_weight).returns(10)
+	    assert_equal 60, order.shipping_cost
+    end
+
+    # illustrates stubbing class method
+    def test_should_count_number_of_orders_shipped_after_specified_date
+      order_1 = Order.new(:shipped_on => 1.week.ago)
+      order_2 = Order.new(:shipped_on => 3.weeks.ago)
+      Order.stubs(:find_all).returns([order_1, order_2])
+      assert_equal 1, Order.number_shipped_since(2.weeks.ago)
+    end
+
+    # illustrates stubbing instance method for all instances of a class
+    def test_should_calculate_value_of_unshipped_orders
+      order_1 = Order.create
+      order_2 = Order.create
+      Order.any_instance.stubs(:shipped_on).returns(Time.now)
+      Order.any_instance.stubs(:total_cost).returns(10)
+      assert_equal 20, Order.unshipped_value
+    end
+
+  end
+
+== Simple AutoMocha Example
+  
+  class Article
+
+    def accepted_comments
+      Comment.find_all_by_article_id(self.id).select { |comment| comment.accepted? }
+    end
+
+  end
+
+  require 'auto_mocha'
+
+  class OrderTest < Test::Unit::TestCase
+
+    include Mocha
+
+    # illustrates stubbing of previously undefined class Comment
+    def test_should_return_accepted_comments_for_this_article
+      unaccepted_comment = Mock.new(:accepted? => false)
+      accepted_comment = Mock.new(:accepted? => true)
+      comments = [unaccepted_comment, accepted_comment]
+      Comment.stubs(:find_all_by_article_id).returns(comments)
+      article = Article.new
+      assert_equal [accepted_comment], article.accepted_comments
+    end
+
+  end

data/lib/auto_mocha.rb

@@ -0,0 +1 @@
+require 'auto_mocha/auto_mock'

data/lib/auto_mocha/auto_mock.rb

@@ -0,0 +1,54 @@
+require 'auto_mocha/mock_class'
+
+class Module
+  
+  def mochas
+    @@mochas ||= {}
+  end
+  
+  def reset_mochas
+    @@mochas = nil
+  end
+
+  def const_missing(symbol)
+    mochas[symbol] ||= Mocha::MockClass.dup
+  end
+  
+  def verify_all
+    mochas.each_value { |mocha| mocha.verify_all }
+  end
+  
+end
+
+Mocha::MockClass.class_eval do
+  
+  class << self
+    
+    def mochas
+      @mochas ||= {}
+    end
+
+    def const_missing(symbol)
+      mochas[symbol] ||= Mocha::MockClass.dup
+    end
+    
+    def verify_all
+      mochas.each_value { |mocha| mocha.verify }
+      verify
+    end
+    
+  end
+
+end
+
+class Test::Unit::TestCase
+  
+  def reset_mochas
+    Object.reset_mochas
+  end
+   
+  def verify_all
+    Object.verify_all
+  end
+  
+end

data/lib/auto_mocha/mock_class.rb

@@ -0,0 +1,38 @@
+require 'mocha/mock_methods'
+
+module Mocha
+
+  class MockClass
+  
+    include MockMethods
+
+    class << self
+    
+      include MockMethods
+    
+      def super_method_missing(symbol, *arguments, &block)
+        superclass.method_missing(symbol, *arguments, &block)
+      end
+        
+      alias_method :__new__, :new
+  
+      def new(*arguments, &block)
+        method_missing(:new, *arguments, &block)
+      end
+        
+      def inherited(subclass)
+        subclass.class_eval do
+
+          def self.new(*arguments, &block)
+            __new__(*arguments, &block)
+          end
+        
+        end
+      
+      end
+    
+    end  
+  
+  end
+
+end

data/lib/mocha.rb

@@ -0,0 +1 @@
+require 'mocha/mock'

data/lib/mocha/expectation.rb

@@ -0,0 +1,116 @@
+require 'mocha/infinite_range'
+require 'mocha/pretty_parameters'
+
+module Mocha
+  class Expectation
+  
+    class InvalidExpectation < Exception; end
+    
+    class AlwaysEqual
+      def ==(other)
+        true
+      end
+      def to_s
+        "** any **"
+      end
+    end
+  
+    attr_reader :method_name
+
+    def initialize(method_name)
+      @method_name = method_name
+      @count = 1
+      @parameters, @parameter_block = AlwaysEqual.new, nil
+      @invoked, @return_value = 0, nil
+    end
+
+    def match?(method_name, *arguments)
+      if @parameter_block then
+        @parameter_block.call(*arguments)
+      else
+        (@method_name == method_name) and (@parameters == arguments)
+      end
+    end
+
+    def times(range)
+      @count = range
+      self
+    end
+  
+    def never
+      times(0)
+    end
+  
+    def at_least(minimum)
+      times(Range.at_least(minimum))
+      self
+    end
+  
+    def at_least_once()
+      at_least(1)
+      self
+    end
+  
+    def with(*arguments, &parameter_block)
+      @parameters, @parameter_block = arguments, parameter_block
+      class << @parameters; def to_s; join(', '); end; end
+      self
+    end
+  
+    def returns(value)
+      @return_value = value
+      self
+    end
+  
+    def raises(exception = RuntimeError, message = nil)
+      @return_value = lambda{ raise exception, message }
+      self
+    end
+
+    def invoke
+      @invoked += 1
+      @return_value.is_a?(Proc) ? @return_value.call : @return_value
+    end
+
+    def verify
+      unless (@count === @invoked) then
+        raise Test::Unit::AssertionFailedError, "#{message}: expected calls: #{@count}, actual calls: #{@invoked}"
+      end
+    end
+  
+    def message
+      params = @parameters.is_a?(Array) ? @parameters : [@parameters.to_s]
+      params = PrettyParameters.new(params)
+      ":#{@method_name}(#{params.pretty})"
+    end
+  
+  end
+
+  class Stub < Expectation
+  
+    def verify
+      true
+    end
+  
+  end
+
+  class MissingExpectation < Expectation
+  
+    def initialize(method_name, expectations = [])
+      super(method_name)
+      @expectations = expectations
+      @invoked = true
+    end
+  
+    def verify
+      msg = "Unexpected message #{message}"
+      msg << "\nSimilar expectations #{similar_expectations.collect { |expectation| expectation.message }.join("\n") }" unless similar_expectations.empty?
+      raise Test::Unit::AssertionFailedError, msg if @invoked
+    end
+  
+    def similar_expectations
+      @expectations.select { |expectation| expectation.method_name == self.method_name }
+    end
+  
+  end
+end

data/lib/mocha/infinite_range.rb

@@ -0,0 +1,27 @@
+class Range
+  
+  def self.at_least(minimum_value)
+    Range.new(minimum_value, infinite)
+  end
+  
+  def self.at_most(maximum_value)
+    Range.new(-infinite, maximum_value, false)
+  end
+  
+  def self.infinite
+    1/0.0
+  end
+  
+  alias_method :__to_s__, :to_s
+
+  def to_s
+    if first.to_f.infinite? then
+      return "at most #{last}"
+    elsif last.to_f.infinite? then
+      return "at least #{first}"
+    else
+      __to_s__
+    end
+  end
+  
+end

data/lib/mocha/inspect.rb

@@ -0,0 +1,37 @@
+require 'date'
+
+class Object
+  def mocha_inspect
+    inspect =~ /#</ ? "#<#{self.class}: #{self.object_id}>" : inspect
+  end
+end
+
+class String
+  def mocha_inspect
+    inspect.gsub(/\"/, "'")
+  end
+end
+
+class Array
+  def mocha_inspect
+    "[#{collect { |member| member.mocha_inspect }.join(', ')}]"
+  end
+end
+
+class Hash
+  def mocha_inspect
+    "{#{collect { |key, value| "#{key.mocha_inspect} => #{value.mocha_inspect}" }.join(', ')}}"
+  end
+end
+
+class Time
+  def mocha_inspect
+    "#{inspect} (#{to_f} secs)"
+  end
+end
+
+class Date
+  def mocha_inspect
+    to_s
+  end
+end

data/lib/mocha/metaclass.rb

@@ -0,0 +1,7 @@
+class Object
+  
+  def metaclass
+    class << self; self; end
+  end
+
+end

data/lib/mocha/mock.rb

@@ -0,0 +1,30 @@
+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
+    end
+  
+    def always_responds
+      Class.new { def respond_to?(symbol); true; end }.new
+    end
+
+  end
+end