mocha 0.5.6 → 0.9.0

data/lib/mocha/parameter_matchers/anything.rb

@@ -4,7 +4,7 @@ module Mocha
   
   module ParameterMatchers
 
-    # :call-seq: anything -> parameter_matcher
+    # :call-seq: anything() -> parameter_matcher
     #
     # Matches any object.
     #   object = mock()

data/lib/mocha/parameter_matchers/has_entries.rb

@@ -1,4 +1,6 @@
 require 'mocha/parameter_matchers/base'
+require 'mocha/parameter_matchers/all_of'
+require 'mocha/parameter_matchers/has_entry'
 
 module Mocha
   
@@ -28,7 +30,8 @@ module Mocha
       
       def matches?(available_parameters)
         parameter = available_parameters.shift
-        @entries.all? { |key, value| parameter[key] == value }
+        has_entry_matchers = @entries.map { |key, value| HasEntry.new(key, value) }
+        AllOf.new(*has_entry_matchers).matches?([parameter])
       end
       
       def mocha_inspect

data/lib/mocha/parameter_matchers/has_entry.rb

@@ -41,11 +41,12 @@ module Mocha
       
       def matches?(available_parameters)
         parameter = available_parameters.shift
-        parameter[@key] == @value
+        matching_keys = parameter.keys.select { |key| @key.to_matcher.matches?([key]) }
+        matching_keys.any? { |key| @value.to_matcher.matches?([parameter[key]]) }
       end
       
       def mocha_inspect
-        "has_entry(#{@key.mocha_inspect}, #{@value.mocha_inspect})"
+        "has_entry(#{@key.mocha_inspect} => #{@value.mocha_inspect})"
       end
       
     end

data/lib/mocha/parameter_matchers/has_key.rb

@@ -28,7 +28,7 @@ module Mocha
       
       def matches?(available_parameters)
         parameter = available_parameters.shift
-        parameter.keys.include?(@key)
+        parameter.keys.any? { |key| @key.to_matcher.matches?([key]) }
       end
       
       def mocha_inspect

data/lib/mocha/parameter_matchers/has_value.rb

@@ -28,7 +28,7 @@ module Mocha
       
       def matches?(available_parameters)
         parameter = available_parameters.shift
-        parameter.values.include?(@value)
+        parameter.values.any? { |value| @value.to_matcher.matches?([value]) }
       end
       
       def mocha_inspect

data/lib/mocha/parameter_matchers/not.rb

@@ -4,9 +4,9 @@ module Mocha
   
   module ParameterMatchers
 
-    # :call-seq: Not(matcher) -> parameter_matcher
+    # :call-seq: Not(parameter_matcher) -> parameter_matcher
     #
-    # Matches if +matcher+ does not match.
+    # Matches if +parameter_matcher+ does not match.
     #   object = mock()
     #   object.expects(:method_1).with(Not(includes(1)))
     #   object.method_1([0, 2, 3])

data/lib/mocha/parameter_matchers/object.rb

@@ -2,7 +2,7 @@ require 'mocha/parameter_matchers/equals'
 
 class Object
   
-  def to_matcher
+  def to_matcher # :nodoc:
     Mocha::ParameterMatchers::Equals.new(self)
   end
   

data/lib/mocha/parameter_matchers/optionally.rb

@@ -2,6 +2,28 @@ module Mocha
   
   module ParameterMatchers
 
+    # :call-seq: optionally(*parameter_matchers) -> parameter_matcher
+    #
+    # Matches optional parameters if available.
+    #   object = mock()
+    #   object.expects(:method_1).with(1, 2, optionally(3, 4))
+    #   object.method_1(1, 2)
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(1, 2, optionally(3, 4))
+    #   object.method_1(1, 2, 3)
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(1, 2, optionally(3, 4))
+    #   object.method_1(1, 2, 3, 4)
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(1, 2, optionally(3, 4))
+    #   object.method_1(1, 2, 3, 5)
+    #   # error raised, because optional parameters did not match
     def optionally(*matchers)
       Optionally.new(*matchers)
     end

data/lib/mocha/parameter_matchers/regexp_matches.rb

@@ -4,9 +4,9 @@ module Mocha
   
   module ParameterMatchers
 
-    # :call-seq: regexp_matches(regexp) -> parameter_matcher
+    # :call-seq: regexp_matches(regular_expression) -> parameter_matcher
     #
-    # Matches any object that matches the regular expression, +regexp+.
+    # Matches any object that matches +regular_expression+.
     #   object = mock()
     #   object.expects(:method_1).with(regexp_matches(/e/))
     #   object.method_1('hello')

data/lib/mocha/parameter_matchers/responds_with.rb

@@ -0,0 +1,43 @@
+require 'mocha/parameter_matchers/base'
+require 'yaml'
+
+module Mocha
+
+  module ParameterMatchers
+
+    # :call-seq: responds_with(message, result) -> parameter_matcher
+    #
+    # Matches any object that responds to +message+ with +result+. To put it another way, it tests the quack, not the duck.
+    #   object = mock()
+    #   object.expects(:method_1).with(responds_with(:upcase, "FOO"))
+    #   object.method_1("foo")
+    #   # no error raised, because "foo".upcase == "FOO"
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(responds_with(:upcase, "BAR"))
+    #   object.method_1("foo")
+    #   # error raised, because "foo".upcase != "BAR"
+    def responds_with(message, result)
+      RespondsWith.new(message, result)
+    end
+
+    class RespondsWith < Base # :nodoc:
+
+      def initialize(message, result)
+        @message, @result = message, result
+      end
+
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        parameter.__send__(@message) == @result
+      end
+
+      def mocha_inspect
+        "responds_with(#{@message.mocha_inspect}, #{@result.mocha_inspect})"
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/mocha/parameter_matchers/yaml_equivalent.rb

@@ -0,0 +1,43 @@
+require 'mocha/parameter_matchers/base'
+require 'yaml'
+
+module Mocha
+
+  module ParameterMatchers
+
+    # :call-seq: yaml_equivalent(object) -> parameter_matcher
+    #
+    # Matches any YAML that represents the specified +object+
+    #   object = mock()
+    #   object.expects(:method_1).with(yaml_equivalent(1, 2, 3))
+    #   object.method_1("--- \n- 1\n- 2\n- 3\n")
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(yaml_equivalent(1, 2, 3))
+    #   object.method_1("--- \n- 1\n- 2\n")
+    #   # error raised, because method_1 was not called with YAML representing the specified Array
+    def yaml_equivalent(object)
+      YamlEquivalent.new(object)
+    end
+
+    class YamlEquivalent < Base # :nodoc:
+
+      def initialize(object)
+        @object = object
+      end
+
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        @object == YAML.load(parameter)
+      end
+
+      def mocha_inspect
+        "yaml_equivalent(#{@object.mocha_inspect})"
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/mocha/single_return_value.rb

@@ -1,5 +1,4 @@
 require 'mocha/is_a'
-require 'mocha/deprecation'
 
 module Mocha # :nodoc:
   
@@ -10,15 +9,9 @@ module Mocha # :nodoc:
     end
     
     def evaluate
-      if @value.__is_a__(Proc) then
-        message = 'use of Expectation#returns with instance of Proc - see Expectation#returns RDoc for alternatives'
-        Deprecation.warning(message)
-        @value.call
-      else
-        @value
-      end
+      @value
     end
     
   end
   
-end
+end

data/lib/mocha/standalone.rb

@@ -1,32 +1,166 @@
-require 'mocha/auto_verify'
 require 'mocha/parameter_matchers'
-require 'mocha/setup_and_teardown'
+require 'mocha/mockery'
+require 'mocha/sequence'
 
-module Mocha
+module Mocha # :nodoc:
   
+  # Methods added to Test::Unit::TestCase or equivalent.
   module Standalone
     
-    include AutoVerify
     include ParameterMatchers
-    include SetupAndTeardown
     
-    def mocha_setup
-      setup_stubs
+    # :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
     
-    def mocha_verify(&block)
-      verify_mocks(&block)
-      verify_stubs(&block)
+    # :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
     
-    def mocha_teardown
-      begin
-        teardown_mocks
-      ensure
-        teardown_stubs
-      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
+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