mocha-macruby 0.9.8.20100129120100

data/lib/mocha/parameter_matchers/not.rb

@@ -0,0 +1,42 @@
+require 'mocha/parameter_matchers/base'
+
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: Not(parameter_matcher) -> parameter_matcher
+    #
+    # Matches if +parameter_matcher+ does not match.
+    #   object = mock()
+    #   object.expects(:method_1).with(Not(includes(1)))
+    #   object.method_1([0, 2, 3])
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(Not(includes(1)))
+    #   object.method_1([0, 1, 2, 3])
+    #   # error raised, because method_1 was not called with object not including 1
+    def Not(matcher)
+      Not.new(matcher)
+    end
+    
+    class Not < Base # :nodoc:
+      
+      def initialize(matcher)
+        @matcher = matcher
+      end
+    
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        !@matcher.matches?([parameter])
+      end
+      
+      def mocha_inspect
+        "Not(#{@matcher.mocha_inspect})"
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/mocha/parameter_matchers/object.rb

@@ -0,0 +1,15 @@
+require 'mocha/parameter_matchers/equals'
+
+module Mocha
+  
+  module ObjectMethods
+    def to_matcher # :nodoc:
+      Mocha::ParameterMatchers::Equals.new(self)
+    end
+  end
+  
+end
+
+class Object
+  include Mocha::ObjectMethods
+end

data/lib/mocha/parameter_matchers/optionally.rb

@@ -0,0 +1,55 @@
+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
+    
+    class Optionally < Base # :nodoc:
+      
+      def initialize(*parameters)
+        @matchers = parameters.map { |parameter| parameter.to_matcher }
+      end
+      
+      def matches?(available_parameters)
+        index = 0
+        while (available_parameters.length > 0) && (index < @matchers.length) do
+          matcher = @matchers[index]
+          return false unless matcher.matches?(available_parameters)
+          index += 1
+        end
+        return true
+      end
+      
+      def mocha_inspect
+        "optionally(#{@matchers.map { |matcher| matcher.mocha_inspect }.join(", ") })"
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/mocha/parameter_matchers/regexp_matches.rb

@@ -0,0 +1,44 @@
+require 'mocha/parameter_matchers/base'
+
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: regexp_matches(regular_expression) -> parameter_matcher
+    #
+    # Matches any object that matches +regular_expression+.
+    #   object = mock()
+    #   object.expects(:method_1).with(regexp_matches(/e/))
+    #   object.method_1('hello')
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(regexp_matches(/a/))
+    #   object.method_1('hello')
+    #   # error raised, because method_1 was not called with a parameter that matched the 
+    #   # regular expression
+    def regexp_matches(regexp)
+      RegexpMatches.new(regexp)
+    end
+
+    class RegexpMatches < Base # :nodoc:
+  
+      def initialize(regexp)
+        @regexp = regexp
+      end
+  
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        return false unless parameter.respond_to?(:=~)
+        parameter =~ @regexp
+      end
+  
+      def mocha_inspect
+        "regexp_matches(#{@regexp.mocha_inspect})"
+      end
+  
+    end
+    
+  end
+  
+end

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/parameters_matcher.rb

@@ -0,0 +1,37 @@
+require 'mocha/inspect'
+require 'mocha/parameter_matchers'
+
+module Mocha
+  
+  class ParametersMatcher
+    
+    def initialize(expected_parameters = [ParameterMatchers::AnyParameters.new], &matching_block)
+      @expected_parameters, @matching_block = expected_parameters, matching_block
+    end
+    
+    def match?(actual_parameters = [])
+      if @matching_block
+        return @matching_block.call(*actual_parameters)
+      else
+        return parameters_match?(actual_parameters)
+      end
+    end
+    
+    def parameters_match?(actual_parameters)
+      matchers.all? { |matcher| matcher.matches?(actual_parameters) } && (actual_parameters.length == 0)
+    end
+    
+    def mocha_inspect
+      signature = matchers.mocha_inspect
+      signature = signature.gsub(/^\[|\]$/, '')
+      signature = signature.gsub(/^\{|\}$/, '') if matchers.length == 1
+      "(#{signature})"
+    end
+    
+    def matchers
+      @expected_parameters.map { |parameter| parameter.to_matcher }
+    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.length == 1
+    end
+  
+  end
+  
+end

data/lib/mocha/return_values.rb

@@ -0,0 +1,31 @@
+require 'mocha/single_return_value'
+
+module Mocha # :nodoc:
+  
+  class ReturnValues # :nodoc:
+    
+    def self.build(*values)
+      new(*values.map { |value| SingleReturnValue.new(value) })
+    end
+    
+    attr_accessor :values
+    
+    def initialize(*values)
+      @values = values
+    end
+    
+    def next
+      case @values.length
+        when 0 then nil
+        when 1 then @values.first.evaluate
+        else @values.shift.evaluate
+      end
+    end
+    
+    def +(other)
+      self.class.new(*(@values + other.values))
+    end
+    
+  end
+  
+end

data/lib/mocha/sequence.rb

@@ -0,0 +1,42 @@
+module Mocha # :nodoc:
+  
+  class Sequence
+    
+    class InSequenceOrderingConstraint
+      
+      def initialize(sequence, index)
+        @sequence, @index = sequence, index
+      end
+      
+      def allows_invocation_now?
+        @sequence.satisfied_to_index?(@index)
+      end
+      
+      def mocha_inspect
+        "in sequence #{@sequence.mocha_inspect}"
+      end
+      
+    end
+    
+    def initialize(name)
+      @name = name
+      @expectations = []
+    end
+    
+    def constrain_as_next_in_sequence(expectation)
+      index = @expectations.length
+      @expectations << expectation
+      expectation.add_ordering_constraint(InSequenceOrderingConstraint.new(self, index))
+    end
+    
+    def satisfied_to_index?(index)
+      @expectations[0...index].all? { |expectation| expectation.satisfied? }
+    end
+    
+    def mocha_inspect
+      "#{@name.mocha_inspect}"
+    end
+    
+  end
+  
+end

data/lib/mocha/single_return_value.rb

@@ -0,0 +1,17 @@
+require 'mocha/is_a'
+
+module Mocha # :nodoc:
+  
+  class SingleReturnValue # :nodoc:
+    
+    def initialize(value)
+      @value = value
+    end
+    
+    def evaluate
+      @value
+    end
+    
+  end
+  
+end

data/lib/mocha/single_yield.rb

@@ -0,0 +1,18 @@
+module Mocha # :nodoc:
+  
+  class SingleYield # :nodoc:
+    
+    attr_reader :parameters
+    
+    def initialize(*parameters)
+      @parameters = parameters
+    end
+    
+    def each
+      yield(@parameters)
+    end
+    
+  end
+  
+end
+    

data/lib/mocha/standalone.rb

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

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