floehopper-mocha 0.9.3.20081220175348

data/lib/mocha/standalone.rb

@@ -0,0 +1,166 @@
+require 'mocha/parameter_matchers'
+require 'mocha/mockery'
+require 'mocha/sequence'
+
+module Mocha # :nodoc:
+  
+  # Methods added to Test::Unit::TestCase or equivalent.
+  module Standalone
+    
+    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 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
+  
+end

data/lib/mocha/state_machine.rb

@@ -0,0 +1,91 @@
+module Mocha # :nodoc:
+
+  # A state machine that is used to constrain the order of invocations.
+  # An invocation can be constrained to occur when a state is, or is_not, active.
+  class StateMachine
+  
+    class State # :nodoc:
+    
+      def initialize(state_machine, state)
+        @state_machine, @state = state_machine, state
+      end
+    
+      def activate
+        @state_machine.current_state = @state
+      end
+    
+      def active?
+        @state_machine.current_state == @state
+      end
+    
+      def mocha_inspect
+        "#{@state_machine.name} is #{@state.mocha_inspect}"
+      end
+    
+    end
+    
+    class StatePredicate # :nodoc:
+      
+      def initialize(state_machine, state)
+        @state_machine, @state = state_machine, state
+      end
+    
+      def active?
+        @state_machine.current_state != @state
+      end
+    
+      def mocha_inspect
+        "#{@state_machine.name} is not #{@state.mocha_inspect}"
+      end
+      
+    end
+    
+    attr_reader :name # :nodoc:
+    
+    attr_accessor :current_state # :nodoc:
+    
+    def initialize(name) # :nodoc:
+      @name = name
+      @current_state = nil
+    end
+    
+    # :call-seq: starts_as(initial_state) -> state_machine
+    #
+    # Put the +state_machine+ into the +initial_state+.
+    def starts_as(initial_state)
+      become(initial_state)
+      self
+    end
+  
+    # :call-seq: become(next_state)
+    #
+    # Put the +state_machine+ into the +next_state+.
+    def become(next_state)
+      @current_state = next_state
+    end
+  
+    # :call-seq: is(state)
+    #
+    # Determines whether the +state_machine+ is in the specified +state+.
+    def is(state)
+      State.new(self, state)
+    end
+  
+    # :call-seq: is_not(state)
+    #
+    # Determines whether the +state_machine+ is not in the specified +state+.
+    def is_not(state)
+      StatePredicate.new(self, state)
+    end
+  
+    def mocha_inspect # :nodoc:
+      if @current_state
+        "#{@name} is #{@current_state.mocha_inspect}"
+      else
+        "#{@name} has no current state"
+      end
+    end
+  
+  end
+
+end

data/lib/mocha/stubbing_error.rb

@@ -0,0 +1,16 @@
+require 'mocha/backtrace_filter'
+
+module Mocha # :nodoc:
+  
+  # Exception raised when an action prevented by Configuration#prevent is attempted.
+  class StubbingError < StandardError
+
+    def initialize(message = nil, backtrace = []) # :nodoc:
+      super(message)
+      filter = BacktraceFilter.new
+      set_backtrace(filter.filtered(backtrace))
+    end
+
+  end
+  
+end

data/lib/mocha/test_case_adapter.rb

@@ -0,0 +1,103 @@
+require 'mocha/expectation_error'
+
+module Mocha
+  
+  module TestCaseAdapter
+    
+    class AssertionCounter
+      
+      def initialize(test_result)
+        @test_result = test_result
+      end
+      
+      def increment
+        @test_result.add_assertion
+      end
+      
+    end
+
+    def self.included(base)
+      if RUBY_VERSION < '1.8.6'
+        base.class_eval do
+
+          alias_method :run_before_mocha_test_case_adapter, :run
+
+          def run(result)
+            assertion_counter = AssertionCounter.new(result)
+            yield(Test::Unit::TestCase::STARTED, name)
+            @_result = result
+            begin
+              begin
+                setup
+                __send__(@method_name)
+                mocha_verify(assertion_counter)
+              rescue Mocha::ExpectationError => e
+                add_failure(e.message, e.backtrace)
+              rescue Test::Unit::AssertionFailedError => e
+                add_failure(e.message, e.backtrace)
+              rescue StandardError, ScriptError
+                add_error($!)
+              ensure
+                begin
+                  teardown
+                rescue Test::Unit::AssertionFailedError => e
+                  add_failure(e.message, e.backtrace)
+                rescue StandardError, ScriptError
+                  add_error($!)
+                end
+              end
+            ensure
+              mocha_teardown
+            end
+            result.add_run
+            yield(Test::Unit::TestCase::FINISHED, name)
+          end
+
+        end
+      else
+        base.class_eval do
+
+          alias_method :run_before_mocha_test_case_adapter, :run
+
+          def run(result)
+            assertion_counter = AssertionCounter.new(result)
+            yield(Test::Unit::TestCase::STARTED, name)
+            @_result = result
+            begin
+              begin
+                setup
+                __send__(@method_name)
+                mocha_verify(assertion_counter)
+              rescue Mocha::ExpectationError => e
+                add_failure(e.message, e.backtrace)
+              rescue Test::Unit::AssertionFailedError => e
+                add_failure(e.message, e.backtrace)
+              rescue Exception
+                raise if Test::Unit::TestCase::PASSTHROUGH_EXCEPTIONS.include? $!.class
+                add_error($!)
+              ensure
+                begin
+                  teardown
+                rescue Test::Unit::AssertionFailedError => e
+                  add_failure(e.message, e.backtrace)
+                rescue Exception
+                  raise if Test::Unit::TestCase::PASSTHROUGH_EXCEPTIONS.include? $!.class
+                  add_error($!)
+                end
+              end
+            ensure
+              mocha_teardown
+            end
+            result.add_run
+            yield(Test::Unit::TestCase::FINISHED, name)
+          end
+                
+        end
+        
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/mocha/unexpected_invocation.rb

@@ -0,0 +1,18 @@
+module Mocha # :nodoc:
+
+  class UnexpectedInvocation
+    
+    def initialize(mock, symbol, *arguments)
+      @mock = mock
+      @method_matcher = MethodMatcher.new(symbol)
+      @parameters_matcher = ParametersMatcher.new(arguments)
+    end
+    
+    def to_s
+      method_signature = "#{@mock.mocha_inspect}.#{@method_matcher.mocha_inspect}#{@parameters_matcher.mocha_inspect}"
+      "unexpected invocation: #{method_signature}\n"
+    end
+    
+  end
+  
+end

data/lib/mocha/yield_parameters.rb

@@ -0,0 +1,31 @@
+require 'mocha/no_yields'
+require 'mocha/single_yield'
+require 'mocha/multiple_yields'
+
+module Mocha # :nodoc:
+  
+  class YieldParameters # :nodoc:
+    
+    def initialize
+      @parameter_groups = []
+    end
+    
+    def next_invocation
+      case @parameter_groups.length
+        when 0 then NoYields.new
+        when 1 then @parameter_groups.first
+        else @parameter_groups.shift
+      end
+    end
+    
+    def add(*parameters)
+      @parameter_groups << SingleYield.new(*parameters)
+    end
+    
+    def multiple_add(*parameter_groups)
+      @parameter_groups << MultipleYields.new(*parameter_groups)
+    end
+    
+  end
+  
+end

data/lib/mocha.rb

@@ -0,0 +1,47 @@
+require 'mocha_standalone'
+require 'mocha/configuration'
+
+if RUBY_VERSION < '1.9'
+  begin
+    require 'rubygems'
+    begin
+      gem 'minitest', '>=1.3'
+      require 'minitest/unit'
+    rescue Gem::LoadError
+      # Compatible version of MiniTest gem not available
+    end
+  rescue LoadError
+    # RubyGems not available
+  end
+else
+  begin
+    require 'minitest/unit'
+  rescue LoadError
+    # MiniTest not available
+  end
+end
+
+if defined?(MiniTest)
+  require 'mocha/mini_test_adapter'
+
+  module MiniTest
+    class Unit
+      class TestCase
+        include Mocha::Standalone
+        include Mocha::MiniTestCaseAdapter
+      end
+    end
+  end
+end
+
+require 'mocha/test_case_adapter'
+require 'test/unit/testcase'
+
+module Test
+  module Unit
+    class TestCase
+      include Mocha::Standalone
+      include Mocha::TestCaseAdapter
+    end
+  end
+end

data/lib/mocha_standalone.rb

@@ -0,0 +1,2 @@
+require 'mocha/standalone'
+require 'mocha/object'

data/lib/stubba.rb

@@ -0,0 +1,4 @@
+# for backwards compatibility
+require 'mocha'
+require 'mocha/deprecation'
+Mocha::Deprecation.warning "require 'stubba' is no longer needed and stubba.rb will soon be removed"

data/test/acceptance/acceptance_test_helper.rb

@@ -0,0 +1,38 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'test_runner'
+require 'mocha/configuration'
+
+module AcceptanceTest
+  
+  class FakeLogger
+  
+    attr_reader :warnings
+    
+    def initialize
+      @warnings = []
+    end
+    
+    def warn(message)
+      @warnings << message
+    end
+  
+  end
+  
+  attr_reader :logger
+
+  include TestRunner
+  
+  def setup_acceptance_test
+    Mocha::Configuration.reset_configuration
+    @logger = FakeLogger.new
+    mockery = Mocha::Mockery.instance
+    @original_logger = mockery.logger
+    mockery.logger = @logger
+  end
+  
+  def teardown_acceptance_test
+    Mocha::Configuration.reset_configuration
+    Mocha::Mockery.instance.logger = @original_logger
+  end
+  
+end

data/test/acceptance/bug_18914_test.rb

@@ -0,0 +1,43 @@
+require File.join(File.dirname(__FILE__), "acceptance_test_helper")
+require 'mocha'
+
+class Bug18914Test < Test::Unit::TestCase
+  
+  include AcceptanceTest
+  
+  def setup
+    setup_acceptance_test
+  end
+  
+  def teardown
+    teardown_acceptance_test
+  end
+  
+  class AlwaysEql
+    
+    def my_method
+      true
+    end
+    
+    def ==(o)
+      true
+    end
+    
+    def eql?(o)
+      true
+    end
+    
+  end
+
+  def test_should_not_allow_stubbing_of_non_mock_instance_disrupted_by_legitimate_overriding_of_eql_method
+    
+    always_eql_1 = AlwaysEql.new
+    always_eql_1.stubs(:my_method).returns(false)
+    
+    always_eql_2 = AlwaysEql.new
+    always_eql_2.stubs(:my_method).returns(false)
+    
+    assert_equal false, always_eql_2.my_method
+  end
+  
+end

data/test/acceptance/bug_21465_test.rb

@@ -0,0 +1,34 @@
+require File.join(File.dirname(__FILE__), "acceptance_test_helper")
+require 'mocha'
+
+class Bug21465Test < Test::Unit::TestCase
+  
+  include AcceptanceTest
+  
+  def setup
+    setup_acceptance_test
+  end
+  
+  def teardown
+    teardown_acceptance_test
+  end
+  
+  def test_should_allow_expected_method_name_to_be_a_string
+    test_result = run_test do
+      mock = mock()
+      mock.expects('wibble')
+      mock.wibble
+    end
+    assert_passed(test_result)
+  end
+  
+  def test_should_allow_stubbed_method_name_to_be_a_string
+    test_result = run_test do
+      mock = mock()
+      mock.stubs('wibble')
+      mock.wibble
+    end
+    assert_passed(test_result)
+  end
+  
+end

data/test/acceptance/bug_21563_test.rb

@@ -0,0 +1,25 @@
+require File.join(File.dirname(__FILE__), "acceptance_test_helper")
+require 'mocha'
+
+class Bug21563Test < Test::Unit::TestCase
+  
+  include AcceptanceTest
+  
+  def setup
+    setup_acceptance_test
+  end
+  
+  def teardown
+    teardown_acceptance_test
+  end
+  
+  def test_should_allow_stubbing_of_verified_method
+    test_result = run_test do
+      object = Object.new
+      object.stubs(:verified?).returns(false)
+      assert !object.verified?
+    end
+    assert_passed(test_result)
+  end
+  
+end