puppet 0.23.2 → 0.24.0

data/test/lib/spec/mocks/errors.rb

@@ -1,10 +0,0 @@
-module Spec
-  module Mocks
-    class MockExpectationError < StandardError
-    end
-    
-    class AmbiguousReturnError < StandardError
-    end
-  end
-end
-

data/test/lib/spec/mocks/extensions/object.rb

@@ -1,3 +0,0 @@
-class Object
-  include Spec::Mocks::Methods
-end

data/test/lib/spec/mocks/message_expectation.rb

@@ -1,231 +0,0 @@
-module Spec
-  module Mocks
-
-    class BaseExpectation
-      attr_reader :sym
-      
-      def initialize(error_generator, expectation_ordering, expected_from, sym, method_block, expected_received_count=1, opts={})
-        @error_generator = error_generator
-        @error_generator.opts = opts
-        @expected_from = expected_from
-        @sym = sym
-        @method_block = method_block
-        @return_block = lambda {}
-        @received_count = 0
-        @expected_received_count = expected_received_count
-        @args_expectation = ArgumentExpectation.new([:any_args])
-        @consecutive = false
-        @exception_to_raise = nil
-        @symbol_to_throw = nil
-        @order_group = expectation_ordering
-        @at_least = nil
-        @at_most = nil
-        @args_to_yield = nil
-      end
-      
-      def expected_args
-        @args_expectation.args
-      end
-
-      def and_return(*values, &return_block)
-        Kernel::raise AmbiguousReturnError unless @method_block.nil?
-        if values.size == 0
-          value = nil
-        elsif values.size == 1
-          value = values[0]
-        else
-          value = values
-          @consecutive = true
-          @expected_received_count = values.size if @expected_received_count != :any &&
-                                                    @expected_received_count < values.size
-        end
-        @return_block = block_given? ? return_block : lambda { value }
-      end
-      
-      def and_raise(exception=Exception)
-        @exception_to_raise = exception
-      end
-      
-      def and_throw(symbol)
-        @symbol_to_throw = symbol
-      end
-      
-      def and_yield(*args)
-        @args_to_yield = args
-      end
-  
-      def matches(sym, args)
-        @sym == sym and @args_expectation.check_args(args)
-      end
-      
-      def invoke(args, block)
-        @order_group.handle_order_constraint self
-
-        begin
-          if @exception_to_raise.class == Class
-            @exception_instance_to_raise = @exception_to_raise.new
-          else 
-            @exception_instance_to_raise = @exception_to_raise
-          end
-          Kernel::raise @exception_to_raise unless @exception_to_raise.nil?
-          Kernel::throw @symbol_to_throw unless @symbol_to_throw.nil?
-
-          if !@method_block.nil?
-            return invoke_method_block(args)
-          elsif !@args_to_yield.nil?
-            return invoke_with_yield(block)
-          elsif @consecutive
-            return invoke_consecutive_return_block(args, block)
-          else
-            return invoke_return_block(args, block)
-          end
-        ensure
-          @received_count += 1
-        end
-      end
-      
-      protected
-
-      def invoke_method_block(args)
-        begin
-          @method_block.call(*args)
-        rescue => detail
-          @error_generator.raise_block_failed_error @sym, detail.message
-        end
-      end
-      
-      def invoke_with_yield(block)
-        if block.nil?
-          @error_generator.raise_missing_block_error @args_to_yield
-        end
-        if block.arity > -1 && @args_to_yield.length != block.arity
-          @error_generator.raise_wrong_arity_error @args_to_yield, block.arity
-        end
-        block.call(*@args_to_yield)
-      end
-      
-      def invoke_consecutive_return_block(args, block)
-        args << block unless block.nil?
-        value = @return_block.call(*args)
-        
-        index = [@received_count, value.size-1].min
-        value[index]
-      end
-      
-      def invoke_return_block(args, block)
-        args << block unless block.nil?
-        value = @return_block.call(*args)
-    
-        value
-      end
-    end
-    
-    class MessageExpectation < BaseExpectation
-      
-      def matches_name_but_not_args(sym, args)
-        @sym == sym and not @args_expectation.check_args(args)
-      end
-       
-      def verify_messages_received        
-        return if @expected_received_count == :any
-        return if (@at_least) && (@received_count >= @expected_received_count)
-        return if (@at_most) && (@received_count <= @expected_received_count)
-        return if @expected_received_count == @received_count
-    
-        begin
-          @error_generator.raise_expectation_error(@sym, @expected_received_count, @received_count, *@args_expectation.args)
-        rescue => error
-          error.backtrace.insert(0, @expected_from)
-          Kernel::raise error
-        end
-      end
-
-      def with(*args, &block)
-        @method_block = block if block
-        @args_expectation = ArgumentExpectation.new(args)
-        self
-      end
-      
-      def exactly(n)
-        set_expected_received_count :exactly, n
-        self
-      end
-      
-      def at_least(n)
-        set_expected_received_count :at_least, n
-        self
-      end
-      
-      def at_most(n)
-        set_expected_received_count :at_most, n
-        self
-      end
-
-      def times(&block)
-        @method_block = block if block
-        self
-      end
-  
-      def any_number_of_times(&block)
-        @method_block = block if block
-        @expected_received_count = :any
-        self
-      end
-  
-      def never
-        @expected_received_count = 0
-        self
-      end
-  
-      def once(&block)
-        @method_block = block if block
-        @expected_received_count = 1
-        self
-      end
-  
-      def twice(&block)
-        @method_block = block if block
-        @expected_received_count = 2
-        self
-      end
-  
-      def ordered(&block)
-        @method_block = block if block
-        @order_group.register(self)
-        @ordered = true
-        self
-      end
-      
-      def negative_expectation_for?(sym)
-        return false
-      end
-      
-      protected
-        def set_expected_received_count(relativity, n)
-          @at_least = (relativity == :at_least)
-          @at_most = (relativity == :at_most)
-          @expected_received_count = 1 if n == :once
-          @expected_received_count = 2 if n == :twice
-          @expected_received_count = n if n.kind_of? Numeric
-        end
-      
-    end
-    
-    class NegativeMessageExpectation < MessageExpectation
-      def initialize(message, expectation_ordering, expected_from, sym, method_block)
-        super(message, expectation_ordering, expected_from, sym, method_block, 0)
-      end
-      
-      def negative_expectation_for?(sym)
-        return @sym == sym
-      end
-    end
-    
-    class MethodStub < BaseExpectation
-      def initialize(message, expectation_ordering, expected_from, sym, method_block)
-        super(message, expectation_ordering, expected_from, sym, method_block, 0)
-        @expected_received_count = :any
-      end
-    end
-  end
-end

data/test/lib/spec/mocks/methods.rb

@@ -1,40 +0,0 @@
-module Spec
-  module Mocks
-    module Methods
-      def should_receive(sym, opts={}, &block)
-        __mock_handler.add_message_expectation(opts[:expected_from] || caller(1)[0], sym, opts, &block)
-      end
-
-      def should_not_receive(sym, &block)
-        __mock_handler.add_negative_message_expectation(caller(1)[0], sym, &block)
-      end
-      
-      def stub!(sym)
-        __mock_handler.add_stub(caller(1)[0], sym)
-      end
-      
-      def received_message?(sym, *args, &block) #:nodoc:
-        __mock_handler.received_message?(sym, *args, &block)
-      end
-      
-      def __verify #:nodoc:
-        __mock_handler.verify
-      end
-
-      def __reset_mock #:nodoc:
-        __mock_handler.reset
-      end
-
-      def method_missing(sym, *args, &block) #:nodoc:
-        __mock_handler.instance_eval {@messages_received << [sym, args, block]}
-        super(sym, *args, &block)
-      end
-      
-      private
-
-      def __mock_handler
-        @mock_handler ||= MockHandler.new(self, @name, @options)
-      end
-    end
-  end
-end

data/test/lib/spec/mocks/mock.rb

@@ -1,26 +0,0 @@
-module Spec
-  module Mocks
-    class Mock
-      include Methods
-
-      # Creates a new mock with a +name+ (that will be used in error messages only)
-      # == Options:
-      # * <tt>:null_object</tt> - if true, the mock object acts as a forgiving null object allowing any message to be sent to it.
-      def initialize(name, options={})
-        @name = name
-        @options = options
-      end
-
-      def method_missing(sym, *args, &block)
-        __mock_handler.instance_eval {@messages_received << [sym, args, block]}
-        begin
-          return self if __mock_handler.null_object?
-          super(sym, *args, &block)
-        rescue NoMethodError
-          __mock_handler.raise_unexpected_message_error sym, *args
-        end
-      end
-      
-    end
-  end
-end

data/test/lib/spec/mocks/mock_handler.rb

@@ -1,166 +0,0 @@
-module Spec
-  module Mocks
-    class MockHandler
-      DEFAULT_OPTIONS = {
-        :null_object => false,
-        :auto_verify => true
-      }
-
-      def initialize(target, name, options={})
-        @target = target
-        @name = name
-        @error_generator = ErrorGenerator.new target, name
-        @expectation_ordering = OrderGroup.new @error_generator
-        @expectations = []
-        @messages_received = []
-        @stubs = []
-        @proxied_methods = []
-        @options = options ? DEFAULT_OPTIONS.dup.merge(options) : DEFAULT_OPTIONS
-      end
-
-      def null_object?
-        @options[:null_object]
-      end
-
-      def add_message_expectation(expected_from, sym, opts={}, &block)
-        __add expected_from, sym, block
-        @expectations << MessageExpectation.new(@error_generator, @expectation_ordering, expected_from, sym, block_given? ? block : nil, 1, opts)
-        @expectations.last
-      end
-
-      def add_negative_message_expectation(expected_from, sym, &block)
-        __add expected_from, sym, block
-        @expectations << NegativeMessageExpectation.new(@error_generator, @expectation_ordering, expected_from, sym, block_given? ? block : nil)
-        @expectations.last
-      end
-
-      def add_stub(expected_from, sym)
-        __add expected_from, sym, nil
-        @stubs.unshift MethodStub.new(@error_generator, @expectation_ordering, expected_from, sym, nil)
-        @stubs.first
-      end
-
-      def verify #:nodoc:
-        begin
-          verify_expectations
-        ensure
-          reset
-        end
-      end
-
-      def reset
-        clear_expectations
-        clear_stubs
-        reset_proxied_methods
-        clear_proxied_methods
-      end
-
-      def received_message?(sym, *args, &block)
-        return true if @messages_received.find {|array| array == [sym, args, block]}
-        return false
-      end
-
-      def has_negative_expectation?(sym)
-        @expectations.detect {|expectation| expectation.negative_expectation_for?(sym)}
-      end
-
-      def message_received(sym, *args, &block)
-        if expectation = find_matching_expectation(sym, *args)
-          expectation.invoke(args, block)
-        elsif stub = find_matching_method_stub(sym)
-          stub.invoke([], block)
-        elsif expectation = find_almost_matching_expectation(sym, *args)
-          raise_unexpected_message_args_error(expectation, *args) unless has_negative_expectation?(sym) unless null_object?
-        else
-          @target.send :method_missing, sym, *args, &block
-        end
-      end
-
-      def raise_unexpected_message_args_error(expectation, *args)
-        @error_generator.raise_unexpected_message_args_error expectation, *args
-      end
-
-      def raise_unexpected_message_error(sym, *args)
-        @error_generator.raise_unexpected_message_error sym, *args
-      end
-      
-      private
-
-      def __add(expected_from, sym, block)
-        # TODO - this is the only reference in the 'spec/mocks' to the Runner
-        current_spec = Runner::Specification.current
-        current_spec.after_teardown {verify} if current_spec && @options[:auto_verify]
-        define_expected_method(sym)
-      end
-      
-      def define_expected_method(sym)
-        if target_responds_to?(sym) && !@proxied_methods.include?(sym)
-          @proxied_methods << sym
-          metaclass.__send__(:alias_method, munge(sym), sym)
-        end
-
-        metaclass_eval(<<-EOF, __FILE__, __LINE__)
-          def #{sym}(*args, &block)
-            __mock_handler.message_received :#{sym}, *args, &block
-          end
-        EOF
-      end
-
-      def target_responds_to?(sym)
-        return @target.send(munge(:respond_to?),sym) if @already_proxied_respond_to
-        return @already_proxied_respond_to = true if sym == :respond_to?
-        return @target.respond_to?(sym)
-      end
-
-      def munge(sym)
-        "proxied_by_rspec__#{sym.to_s}".to_sym
-      end
-
-      def clear_expectations
-        @expectations.clear
-      end
-
-      def clear_stubs
-        @stubs.clear
-      end
-
-      def clear_proxied_methods
-        @proxied_methods.clear
-      end
-
-      def metaclass_eval(str, filename, lineno)
-        metaclass.class_eval(str, filename, lineno)
-      end
-      
-      def metaclass
-        (class << @target; self; end)
-      end
-
-      def verify_expectations
-        @expectations.each do |expectation|
-          expectation.verify_messages_received
-        end
-      end
-
-      def reset_proxied_methods
-        @proxied_methods.each do |sym|
-          metaclass.__send__(:alias_method, sym, munge(sym))
-          metaclass.__send__(:undef_method, munge(sym))
-        end
-      end
-
-      def find_matching_expectation(sym, *args)
-        @expectations.find {|expectation| expectation.matches(sym, args)}
-      end
-
-      def find_almost_matching_expectation(sym, *args)
-        @expectations.find {|expectation| expectation.matches_name_but_not_args(sym, args)}
-      end
-
-      def find_matching_method_stub(sym)
-        @stubs.find {|stub| stub.matches(sym, [])}
-      end
-
-    end
-  end
-end