jferris-mocha 0.9.5.0.1240002286

data/lib/mocha/any_instance_method.rb

@@ -0,0 +1,55 @@
+require 'mocha/class_method'
+
+module Mocha
+
+  class AnyInstanceMethod < ClassMethod
+  
+    def unstub
+      remove_new_method
+      restore_original_method
+      stubbee.any_instance.reset_mocha
+    end
+    
+    def mock
+      stubbee.any_instance.mocha
+    end
+   
+    def hide_original_method
+      if method_exists?(method)
+        begin
+          stubbee.send(:alias_method, hidden_method, method)
+        rescue NameError
+          # deal with nasties like ActiveRecord::Associations::AssociationProxy
+        end
+      end
+    end
+
+    def define_new_method
+      stubbee.class_eval("def #{method}(*args, &block); self.class.any_instance.mocha.method_missing(:#{method}, *args, &block); end", __FILE__, __LINE__)
+    end
+
+    def remove_new_method
+      stubbee.send(:remove_method, method)
+    end
+
+    def restore_original_method
+      if method_exists?(hidden_method)
+        begin
+          stubbee.send(:alias_method, method, hidden_method)
+          stubbee.send(:remove_method, hidden_method)
+        rescue NameError
+          # deal with nasties like ActiveRecord::Associations::AssociationProxy
+        end
+      end
+    end
+
+    def method_exists?(method)
+      return true if stubbee.public_instance_methods(false).include?(method)
+      return true if stubbee.protected_instance_methods(false).include?(method)
+      return true if stubbee.private_instance_methods(false).include?(method)
+      return false
+    end
+    
+  end
+  
+end

data/lib/mocha/api.rb

@@ -0,0 +1,232 @@
+require 'mocha/parameter_matchers'
+require 'mocha/mockery'
+require 'mocha/sequence'
+
+module Mocha # :nodoc:
+  
+  # Methods added to Test::Unit::TestCase or equivalent.
+  module API
+    
+    include ParameterMatchers
+    
+    # :call-seq: mock(name, &block) -> mock object
+    #            mock(expected_methods = {}, &block) -> mock object
+    #            mock(name, expected_methods = {}, &block) -> mock object
+    #
+    # Creates a mock object.
+    #
+    # +name+ is a +String+ identifier for the mock object.
+    #
+    # +expected_methods+ is a +Hash+ with expected method name symbols as keys and corresponding return values as values.
+    #
+    # Note that (contrary to expectations set up by #stub) these expectations <b>must</b> be fulfilled during the test.
+    #   def test_product
+    #     product = mock('ipod_product', :manufacturer => 'ipod', :price => 100)
+    #     assert_equal 'ipod', product.manufacturer
+    #     assert_equal 100, product.price
+    #     # an error will be raised unless both Product#manufacturer and Product#price have been called
+    #   end 
+    #
+    # +block+ is an optional block to be evaluated against the mock object instance, giving an alernative way to set up expectations & stubs.
+    #   def test_product
+    #     product = mock('ipod_product') do
+    #       expects(:manufacturer).returns('ipod')
+    #       expects(:price).returns(100)
+    #     end
+    #     assert_equal 'ipod', product.manufacturer
+    #     assert_equal 100, product.price
+    #     # an error will be raised unless both Product#manufacturer and Product#price have been called
+    #   end 
+    def mock(*arguments, &block)
+      name = arguments.shift if arguments.first.is_a?(String)
+      expectations = arguments.shift || {}
+      mock = name ? Mockery.instance.named_mock(name, &block) : Mockery.instance.unnamed_mock(&block)
+      mock.expects(expectations)
+      mock
+    end
+    
+    # :call-seq: stub(name, &block) -> mock object
+    #            stub(stubbed_methods = {}, &block) -> mock object
+    #            stub(name, stubbed_methods = {}, &block) -> mock object
+    #
+    # Creates a mock object.
+    #
+    # +name+ is a +String+ identifier for the mock object.
+    #
+    # +stubbed_methods+ is a +Hash+ with stubbed method name symbols as keys and corresponding return values as values.
+    # Note that (contrary to expectations set up by #mock) these expectations <b>need not</b> be fulfilled during the test.
+    #   def test_product
+    #     product = stub('ipod_product', :manufacturer => 'ipod', :price => 100)
+    #     assert_equal 'ipod', product.manufacturer
+    #     assert_equal 100, product.price
+    #     # an error will not be raised even if Product#manufacturer and Product#price have not been called
+    #   end
+    #
+    # +block+ is an optional block to be evaluated against the mock object instance, giving an alernative way to set up expectations & stubs.
+    #   def test_product
+    #     product = stub('ipod_product') do
+    #       stubs(:manufacturer).returns('ipod')
+    #       stubs(:price).returns(100)
+    #     end
+    #     assert_equal 'ipod', product.manufacturer
+    #     assert_equal 100, product.price
+    #     # an error will not be raised even if Product#manufacturer and Product#price have not been called
+    #   end
+    def stub(*arguments, &block)
+      name = arguments.shift if arguments.first.is_a?(String)
+      expectations = arguments.shift || {}
+      stub = name ? Mockery.instance.named_mock(name, &block) : Mockery.instance.unnamed_mock(&block)
+      stub.stubs(expectations)
+      stub
+    end
+    
+    # :call-seq: stub_everything(name, &block) -> mock object
+    #            stub_everything(stubbed_methods = {}, &block) -> mock object
+    #            stub_everything(name, stubbed_methods = {}, &block) -> mock object
+    #
+    # Creates a mock object that accepts calls to any method.
+    #
+    # By default it will return +nil+ for any method call.
+    #
+    # +block+ is a block to be evaluated against the mock object instance, giving an alernative way to set up expectations & stubs.
+    #
+    # +name+ and +stubbed_methods+ work in the same way as for #stub.
+    #   def test_product
+    #     product = stub_everything('ipod_product', :price => 100)
+    #     assert_nil product.manufacturer
+    #     assert_nil product.any_old_method
+    #     assert_equal 100, product.price
+    #   end
+    def stub_everything(*arguments, &block)
+      name = arguments.shift if arguments.first.is_a?(String)
+      expectations = arguments.shift || {}
+      stub = name ? Mockery.instance.named_mock(name, &block) : Mockery.instance.unnamed_mock(&block)
+      stub.stub_everything
+      stub.stubs(expectations)
+      stub
+    end
+    
+    # :call-seq: sequence(name) -> sequence
+    #
+    # Returns a new sequence that is used to constrain the order in which expectations can occur.
+    #
+    # Specify that an expected invocation must occur in within a named +sequence+ by using Expectation#in_sequence.
+    #
+    # See also Expectation#in_sequence.
+    #   breakfast = sequence('breakfast')
+    #
+    #   egg = mock('egg')
+    #   egg.expects(:crack).in_sequence(breakfast)
+    #   egg.expects(:fry).in_sequence(breakfast)
+    #   egg.expects(:eat).in_sequence(breakfast)
+    def sequence(name)
+      Sequence.new(name)
+    end
+    
+    # :call-seq: states(name) -> state_machine
+    #
+    # Returns a new +state_machine+ that is used to constrain the order in which expectations can occur.
+    #
+    # Specify the initial +state+ of the +state_machine+ by using StateMachine#starts_as.
+    #
+    # Specify that an expected invocation should change the +state+ of the +state_machine+ by using Expectation#then.
+    #
+    # Specify that an expected invocation should be constrained to occur within a particular +state+ by using Expectation#when.
+    #
+    # A test can contain multiple +state_machines+.
+    #
+    # See also Expectation#then, Expectation#when and StateMachine.
+    #   power = states('power').starts_as('off')
+    #
+    #   radio = mock('radio')
+    #   radio.expects(:switch_on).then(power.is('on'))
+    #   radio.expects(:select_channel).with('BBC Radio 4').when(power.is('on'))
+    #   radio.expects(:adjust_volume).with(+5).when(power.is('on'))
+    #   radio.expects(:select_channel).with('BBC World Service').when(power.is('on'))
+    #   radio.expects(:adjust_volume).with(-5).when(power.is('on'))
+    #   radio.expects(:switch_off).then(power.is('off'))
+    def states(name)
+      Mockery.instance.new_state_machine(name)
+    end
+    
+    def assert_received(mock, expected_method_name)
+      matcher = have_received(expected_method_name)
+      yield(matcher) if block_given?
+      assert matcher.matches?(mock), matcher.failure_message
+    end
+
+    class HaveReceived #:nodoc:
+      def initialize(expected_method_name)
+        @expected_method_name = expected_method_name
+        @expectations = []
+      end
+
+      def method_missing(method, *args, &block)
+        @expectations << [method, args, block]
+        self
+      end
+
+      def matches?(mock)
+        if mock.respond_to?(:mocha)
+          @mock = mock.mocha
+        else
+          mock = @mock
+        end
+
+        @expectation = Expectation.new(@mock, @expected_method_name)
+        @expectations.each do |method, args, block|
+          @expectation.send(method, *args, &block)
+        end
+        @expectation.invocation_count = invocation_count
+        @expectation.satisfied?
+      end
+      
+      def failure_message
+        @expectation.mocha_inspect
+      end
+
+      private
+
+      def invocation_count
+        matching_invocations.size
+      end
+
+      def matching_invocations
+        invocations.select do |invocation|
+          @expectation.match?(invocation.method_name, *invocation.arguments)
+        end
+      end
+
+      def invocations
+        Mockery.instance.invocations.select do |invocation|
+          invocation.mock.equal?(@mock)
+        end
+      end
+    end
+
+    def have_received(expected_method_name)
+      HaveReceived.new(expected_method_name)
+    end
+
+    def mocha_setup # :nodoc:
+    end
+    
+    def mocha_verify(assertion_counter = nil) # :nodoc:
+      Mockery.instance.verify(assertion_counter)
+    end
+    
+    def mocha_teardown # :nodoc:
+      Mockery.instance.teardown
+      Mockery.reset_instance
+    end
+    
+  end
+  
+  def self.const_missing(name)
+    return super unless name == :Standalone
+    require 'mocha/deprecation'
+    Deprecation.warning "Mocha::Standalone has been renamed to Mocha::API"
+    return API
+  end
+  
+end

data/lib/mocha/argument_iterator.rb

@@ -0,0 +1,21 @@
+module Mocha
+  
+  class ArgumentIterator
+  
+    def initialize(argument)
+      @argument = argument
+    end
+  
+    def each(&block)
+      if @argument.is_a?(Hash) then
+        @argument.each do |method_name, return_value|
+          block.call(method_name, return_value)
+        end
+      else
+        block.call(@argument)
+      end
+    end
+  
+  end
+  
+end

data/lib/mocha/backtrace_filter.rb

@@ -0,0 +1,17 @@
+module Mocha
+
+  class BacktraceFilter
+  
+    LIB_DIRECTORY = File.expand_path(File.join(File.dirname(__FILE__), "..")) + File::SEPARATOR
+
+    def initialize(lib_directory = LIB_DIRECTORY)
+      @lib_directory = lib_directory
+    end
+
+    def filtered(backtrace)
+      backtrace.reject { |location| Regexp.new(@lib_directory).match(File.expand_path(location)) }
+    end
+
+  end
+
+end

data/lib/mocha/cardinality.rb

@@ -0,0 +1,95 @@
+module Mocha
+
+  class Cardinality
+    
+    INFINITY = 1 / 0.0
+    
+    class << self
+      
+      def exactly(count)
+        new(count, count)
+      end
+      
+      def at_least(count)
+        new(count, INFINITY)
+      end
+      
+      def at_most(count)
+        new(0, count)
+      end
+      
+      def times(range_or_count)
+        case range_or_count
+          when Range then new(range_or_count.first, range_or_count.last)
+          else new(range_or_count, range_or_count)
+        end
+      end
+      
+    end
+    
+    def initialize(required, maximum)
+      @required, @maximum = required, maximum
+    end
+    
+    def invocations_allowed?(invocation_count)
+      invocation_count < maximum
+    end
+    
+    def satisfied?(invocations_so_far)
+      invocations_so_far >= required
+    end
+    
+    def needs_verifying?
+      !allowed_any_number_of_times?
+    end
+    
+    def verified?(invocation_count)
+      (invocation_count >= required) && (invocation_count <= maximum)
+    end
+    
+    def allowed_any_number_of_times?
+      required == 0 && infinite?(maximum)
+    end
+    
+    def used?(invocation_count)
+      (invocation_count > 0) || (maximum == 0)
+    end
+    
+    def mocha_inspect
+      if allowed_any_number_of_times?
+        "allowed any number of times"
+      else
+        if required == 0 && maximum == 0
+          "expected never"
+        elsif required == maximum
+          "expected exactly #{times(required)}"
+        elsif infinite?(maximum)
+          "expected at least #{times(required)}"
+        elsif required == 0
+          "expected at most #{times(maximum)}"
+        else
+          "expected between #{required} and #{times(maximum)}"
+        end
+      end
+    end
+    
+    protected
+    
+    attr_reader :required, :maximum
+    
+    def times(number)
+      case number
+        when 0 then "no times"
+        when 1 then "once"
+        when 2 then "twice"
+        else "#{number} times"
+      end
+    end
+    
+    def infinite?(number)
+      number.respond_to?(:infinite?) && number.infinite?
+    end
+    
+  end
+  
+end

data/lib/mocha/central.rb

@@ -0,0 +1,27 @@
+module Mocha
+  
+  class Central
+  
+    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.length > 0
+        method = stubba_methods.pop
+        method.unstub
+      end
+    end
+
+  end
+
+end

data/lib/mocha/change_state_side_effect.rb

@@ -0,0 +1,19 @@
+module Mocha
+
+  class ChangeStateSideEffect
+  
+    def initialize(state)
+      @state = state
+    end
+  
+    def perform
+      @state.activate
+    end
+  
+    def mocha_inspect
+      "then #{@state.mocha_inspect}"
+    end
+  
+  end
+
+end

data/lib/mocha/class_method.rb

@@ -0,0 +1,87 @@
+require 'mocha/metaclass'
+
+module Mocha
+
+  class ClassMethod
+  
+    attr_reader :stubbee, :method
+   
+    def initialize(stubbee, method)
+      @stubbee = stubbee
+      @method = RUBY_VERSION < '1.9' ? method.to_s : method.to_sym
+    end
+  
+    def stub
+      hide_original_method
+      define_new_method
+    end
+  
+    def unstub
+      remove_new_method
+      restore_original_method
+      stubbee.reset_mocha
+    end
+    
+    def mock
+      stubbee.mocha
+    end
+  
+    def hide_original_method
+      if method_exists?(method)
+        begin
+          stubbee.__metaclass__.send(:alias_method, hidden_method, method)
+        rescue NameError
+          # deal with nasties like ActiveRecord::Associations::AssociationProxy
+        end
+      end
+    end
+  
+    def define_new_method
+      stubbee.__metaclass__.class_eval("def #{method}(*args, &block); mocha.method_missing(:#{method}, *args, &block); end", __FILE__, __LINE__)
+    end
+  
+    def remove_new_method
+      stubbee.__metaclass__.send(:remove_method, method)
+    end
+  
+    def restore_original_method
+      if method_exists?(hidden_method)
+        begin
+          stubbee.__metaclass__.send(:alias_method, method, hidden_method)
+          stubbee.__metaclass__.send(:remove_method, hidden_method)
+        rescue NameError
+          # deal with nasties like ActiveRecord::Associations::AssociationProxy
+        end
+      end
+    end
+  
+    def hidden_method
+      if RUBY_VERSION < '1.9'
+        method_name = method.to_s.gsub(/\W/) { |s| "_substituted_character_#{s[0]}_" }
+      else
+        method_name = method.to_s.gsub(/\W/) { |s| "_substituted_character_#{s.ord}_" }
+      end
+      hidden_method = "__stubba__#{method_name}__stubba__"
+      RUBY_VERSION < '1.9' ? hidden_method.to_s : hidden_method.to_sym
+    end  
+  
+    def eql?(other)
+      return false unless (other.class == self.class)
+      (stubbee.object_id == other.stubbee.object_id) and (method == other.method)
+    end
+  
+    alias_method :==, :eql?
+  
+    def to_s
+      "#{stubbee}.#{method}"
+    end
+    
+    def method_exists?(method)
+      symbol = method.to_sym
+      metaclass = stubbee.__metaclass__
+      metaclass.public_method_defined?(symbol) || metaclass.protected_method_defined?(symbol) || metaclass.private_method_defined?(symbol)
+    end
+
+  end
+  
+end

data/lib/mocha/configuration.rb

@@ -0,0 +1,60 @@
+module Mocha # :nodoc:
+  
+  # Configuration settings
+  class Configuration
+    
+    DEFAULTS = { :stubbing_method_unnecessarily => :allow, :stubbing_method_on_non_mock_object => :allow, :stubbing_non_existent_method => :allow, :stubbing_non_public_method => :allow }
+    
+    class << self
+    
+      # :call-seq: allow(action)
+      #
+      # Allow the specified <tt>action</tt> (as a symbol).
+      # The <tt>actions</tt> currently available are <tt>:stubbing_method_unnecessarily, :stubbing_method_on_non_mock_object, :stubbing_non_existent_method, :stubbing_non_public_method</tt>.
+      def allow(action)
+        configuration[action] = :allow
+      end
+    
+      def allow?(action) # :nodoc:
+        configuration[action] == :allow
+      end
+    
+      # :call-seq: warn_when(action)
+      #
+      # Warn if the specified <tt>action</tt> (as a symbol) is attempted.
+      # The <tt>actions</tt> currently available are <tt>:stubbing_method_unnecessarily, :stubbing_method_on_non_mock_object, :stubbing_non_existent_method, :stubbing_non_public_method</tt>.
+      def warn_when(action)
+        configuration[action] = :warn
+      end
+    
+      def warn_when?(action) # :nodoc:
+        configuration[action] == :warn
+      end
+    
+      # :call-seq: prevent(action)
+      #
+      # Raise a StubbingError if the specified <tt>action</tt> (as a symbol) is attempted.
+      # The <tt>actions</tt> currently available are <tt>:stubbing_method_unnecessarily, :stubbing_method_on_non_mock_object, :stubbing_non_existent_method, :stubbing_non_public_method</tt>.
+      def prevent(action)
+        configuration[action] = :prevent
+      end
+    
+      def prevent?(action) # :nodoc:
+        configuration[action] == :prevent
+      end
+    
+      def reset_configuration # :nodoc:
+        @configuration = nil
+      end
+    
+      private
+    
+      def configuration # :nodoc:
+        @configuration ||= DEFAULTS.dup
+      end
+    
+    end
+    
+  end
+  
+end

data/lib/mocha/deprecation.rb

@@ -0,0 +1,22 @@
+module Mocha
+  
+  class Deprecation
+    
+    class << self
+      
+      attr_accessor :mode, :messages
+      
+      def warning(message)
+        @messages << message
+        $stderr.puts "Mocha deprecation warning: #{message}" unless mode == :disabled
+        $stderr.puts caller.join("\n  ") if mode == :debug
+      end
+
+    end
+  
+    self.mode = :enabled
+    self.messages = []
+    
+  end
+   
+end

data/lib/mocha/exception_raiser.rb

@@ -0,0 +1,17 @@
+module Mocha # :nodoc:
+  
+  class ExceptionRaiser # :nodoc:
+    
+    def initialize(exception, message)
+      @exception, @message = exception, message
+    end
+    
+    def evaluate
+      raise @exception, @exception.to_s if @exception.is_a?(Module) && @exception.ancestors.include?(Interrupt)
+      raise @exception, @message if @message
+      raise @exception
+    end
+    
+  end
+  
+end