opal-rspec-cj 0.4.4

data/vendor_lib/rspec/mocks/targets.rb

@@ -0,0 +1,90 @@
+module RSpec
+  module Mocks
+    UnsupportedMatcherError  = Class.new(StandardError)
+    NegationUnsupportedError = Class.new(StandardError)
+
+    class TargetBase
+      def initialize(target)
+        @target = target
+      end
+
+      def self.delegate_to(matcher_method)
+        define_method(:to) do |matcher, &block|
+          unless Matchers::Receive === matcher || Matchers::ReceiveMessages === matcher
+            raise_unsupported_matcher(:to, matcher)
+          end
+          define_matcher(matcher, matcher_method, &block)
+        end
+      end
+
+      def self.delegate_not_to(matcher_method, options = {})
+        method_name = options.fetch(:from)
+        define_method(method_name) do |matcher, &block|
+          case matcher
+          when Matchers::Receive         then define_matcher(matcher, matcher_method, &block)
+          when Matchers::ReceiveMessages then raise_negation_unsupported(method_name, matcher)
+          else
+            raise_unsupported_matcher(method_name, matcher)
+          end
+        end
+      end
+
+      def self.disallow_negation(method_name)
+        define_method(method_name) do |matcher, *args|
+          raise_negation_unsupported(method_name, matcher)
+        end
+      end
+
+    private
+
+      def define_matcher(matcher, name, &block)
+        matcher.__send__(name, @target, &block)
+      end
+
+      def raise_unsupported_matcher(method_name, matcher)
+        raise UnsupportedMatcherError,
+          "only the `receive` or `receive_messages` matchers are supported " +
+          "with `#{expression}(...).#{method_name}`, but you have provided: #{matcher}"
+      end
+
+      def raise_negation_unsupported(method_name, matcher)
+        raise NegationUnsupportedError,
+          "`#{expression}(...).#{method_name} #{matcher.name}` is not supported since it " +
+          "doesn't really make sense. What would it even mean?"
+      end
+
+      def expression
+        self.class::EXPRESSION
+      end
+    end
+
+    class AllowanceTarget < TargetBase
+      EXPRESSION = :allow
+      delegate_to :setup_allowance
+      disallow_negation :not_to
+      disallow_negation :to_not
+    end
+
+    class ExpectationTarget < TargetBase
+      EXPRESSION = :expect
+      delegate_to :setup_expectation
+      delegate_not_to :setup_negative_expectation, :from => :not_to
+      delegate_not_to :setup_negative_expectation, :from => :to_not
+    end
+
+    class AnyInstanceAllowanceTarget < TargetBase
+      EXPRESSION = :allow_any_instance_of
+      delegate_to :setup_any_instance_allowance
+      disallow_negation :not_to
+      disallow_negation :to_not
+    end
+
+    class AnyInstanceExpectationTarget < TargetBase
+      EXPRESSION = :expect_any_instance_of
+      delegate_to :setup_any_instance_expectation
+      delegate_not_to :setup_any_instance_negative_expectation, :from => :not_to
+      delegate_not_to :setup_any_instance_negative_expectation, :from => :to_not
+    end
+  end
+end
+

data/vendor_lib/rspec/mocks/test_double.rb

@@ -0,0 +1,109 @@
+module RSpec
+  module Mocks
+    # Implements the methods needed for a pure test double.  RSpec::Mocks::Mock
+    # includes this module, and it is provided for cases where you want a
+    # pure test double without subclassing RSpec::Mocks::Mock.
+    module TestDouble
+      # Extends the TestDouble module onto the given object and
+      # initializes it as a test double.
+      #
+      # @example
+      #
+      #   module = Module.new
+      #   RSpec::Mocks::TestDouble.extend_onto(module, "MyMixin", :foo => "bar")
+      #   module.foo  #=> "bar"
+      def self.extend_onto(object, name=nil, stubs={})
+        object.extend self
+        object.send(:__initialize_as_test_double, name, stubs)
+      end
+
+      # Creates a new test double with a `name` (that will be used in error
+      # messages only)
+      def initialize(name=nil, stubs={})
+        __initialize_as_test_double(name, stubs)
+      end
+
+      # Tells the object to respond to all messages. If specific stub values
+      # are declared, they'll work as expected. If not, the receiver is
+      # returned.
+      def as_null_object
+        __mock_proxy.as_null_object
+      end
+
+      # Returns true if this object has received `as_null_object`
+      def null_object?
+        __mock_proxy.null_object?
+      end
+
+      # This allows for comparing the mock to other objects that proxy such as
+      # ActiveRecords belongs_to proxy objects. By making the other object run
+      # the comparison, we're sure the call gets delegated to the proxy
+      # target.
+      def ==(other)
+        other == __mock_proxy
+      end
+
+      # @private
+      def inspect
+        "#<#{self.class}:#{sprintf '0x%x', self.object_id} @name=#{@name.inspect}>"
+      end
+
+      # @private
+      def to_s
+        inspect.gsub('<','[').gsub('>',']')
+      end
+
+      alias_method :to_str, :to_s
+
+      # @private
+      def respond_to?(message, incl_private=false)
+        __mock_proxy.null_object? ? true : super
+      end
+
+      # @private
+      def __build_mock_proxy(order_group)
+        Proxy.new(self, order_group, @name)
+      end
+
+    private
+
+      def __initialize_as_test_double(name=nil, stubs={})
+        if Hash === name && stubs.empty?
+          stubs = name
+          @name = nil
+        else
+          @name = name
+        end
+        assign_stubs(stubs)
+      end
+
+      def method_missing(message, *args, &block)
+        if __mock_proxy.null_object?
+          case message
+          when :to_int        then return 0
+          when :to_a, :to_ary then return nil
+          end
+        end
+        __mock_proxy.record_message_received(message, *args, &block)
+
+        begin
+          __mock_proxy.null_object? ? self : super
+        rescue NameError
+          # Required wrapping doubles in an Array on Ruby 1.9.2
+          raise NoMethodError if [:to_a, :to_ary].include? message
+          __mock_proxy.raise_unexpected_message_error(message, *args)
+        end
+      end
+
+      def assign_stubs(stubs)
+        stubs.each_pair do |message, response|
+          __mock_proxy.add_simple_stub(message, response)
+        end
+      end
+
+      def __mock_proxy
+        ::RSpec::Mocks.proxy_for(self)
+      end
+    end
+  end
+end

data/vendor_lib/rspec/mocks/verifying_double.rb

@@ -0,0 +1,77 @@
+require 'rspec/mocks/mock'
+require 'rspec/mocks/verifying_proxy'
+
+module RSpec
+  module Mocks
+
+    module VerifyingDouble
+      def method_missing(message, *args, &block)
+        # Null object conditional is an optimization. If not a null object,
+        # validity of method expectations will have been checked at definition
+        # time.
+        __mock_proxy.ensure_implemented(message) if null_object?
+        super
+      end
+    end
+
+    # A mock providing a custom proxy that can verify the validity of any
+    # method stubs or expectations against the public instance methods of the
+    # given class.
+    class InstanceVerifyingDouble
+      include TestDouble
+      include VerifyingDouble
+
+      def initialize(doubled_module, *args)
+        @doubled_module = doubled_module
+
+        __initialize_as_test_double(doubled_module, *args)
+      end
+
+      def __build_mock_proxy(order_group)
+        VerifyingProxy.new(self, order_group,
+          @doubled_module,
+          InstanceMethodReference
+        )
+      end
+    end
+
+    # An awkward module necessary because we cannot otherwise have
+    # ClassVerifyingDouble inherit from Module and still share these methods.
+    module ObjectVerifyingDoubleMethods
+      include TestDouble
+      include VerifyingDouble
+
+      def initialize(doubled_module, *args)
+        @doubled_module = doubled_module
+
+        __initialize_as_test_double(doubled_module, *args)
+      end
+
+      def __build_mock_proxy(order_group)
+        VerifyingProxy.new(self, order_group,
+          @doubled_module,
+          ObjectMethodReference
+        )
+      end
+
+      def as_stubbed_const(options = {})
+        ConstantMutator.stub(@doubled_module.const_to_replace, self, options)
+        self
+      end
+    end
+
+    # Similar to an InstanceVerifyingDouble, except that it verifies against
+    # public methods of the given object.
+    class ObjectVerifyingDouble
+      include ObjectVerifyingDoubleMethods
+    end
+
+    # Effectively the same as an ObjectVerifyingDouble (since a class is a type
+    # of object), except with Module in the inheritance chain so that
+    # transferring nested constants to work.
+    class ClassVerifyingDouble < Module
+      include ObjectVerifyingDoubleMethods
+    end
+
+  end
+end

data/vendor_lib/rspec/mocks/verifying_message_expecation.rb

@@ -0,0 +1,60 @@
+require 'rspec/mocks/arity_calculator'
+
+module RSpec
+  module Mocks
+
+    # A message expectation that knows about the real implementation of the
+    # message being expected, so that it can verify that any expectations
+    # have the correct arity.
+    class VerifyingMessageExpectation < MessageExpectation
+
+      # A level of indirection is used here rather than just passing in the
+      # method itself, since method look up is expensive and we only want to
+      # do it if actually needed.
+      #
+      # Conceptually the method reference makes more sense as a constructor
+      # argument since it should be immutable, but it is significantly more
+      # straight forward to build the object in pieces so for now it stays as
+      # an accessor.
+      attr_accessor :method_reference
+
+      def initialize(*args)
+        super
+      end
+
+      # @override
+      def with(*args, &block)
+        unless ArgumentMatchers::AnyArgsMatcher === args.first
+          expected_arity = if ArgumentMatchers::NoArgsMatcher === args.first
+            0
+          elsif args.length > 0
+            args.length
+          else
+            # No arguments given, this will raise.
+            super
+          end
+
+          ensure_arity!(expected_arity)
+        end
+        super
+      end
+
+    private
+
+      def ensure_arity!(actual)
+        return if method_reference.nil?
+
+        method_reference.when_defined do |method|
+          calculator = ArityCalculator.new(method)
+          unless calculator.within_range?(actual)
+            # Fail fast is required, otherwise the message expecation will fail
+            # as well ("expected method not called") and clobber this one.
+            @failed_fast = true
+            @error_generator.raise_arity_error(calculator, actual)
+          end
+        end
+      end
+    end
+  end
+end
+

data/vendor_lib/rspec/mocks/verifying_proxy.rb

@@ -0,0 +1,151 @@
+require 'rspec/mocks/verifying_message_expecation'
+require 'rspec/mocks/method_reference'
+
+module RSpec
+  module Mocks
+
+    module VerifyingProxyMethods
+      def add_stub(location, method_name, opts={}, &implementation)
+        ensure_implemented(method_name)
+        super
+      end
+
+      def add_simple_stub(method_name, *args)
+        ensure_implemented(method_name)
+        super
+      end
+
+      def add_message_expectation(location, method_name, opts={}, &block)
+        ensure_implemented(method_name)
+        super
+      end
+
+      def ensure_implemented(method_name)
+        return unless @doubled_module.defined?
+
+        method_reference[method_name].when_unimplemented do
+          @error_generator.raise_unimplemented_error(
+            @doubled_module,
+            method_name
+          )
+        end
+      end
+    end
+
+    # A verifying proxy mostly acts like a normal proxy, except that it
+    # contains extra logic to try and determine the validity of any expectation
+    # set on it. This includes whether or not methods have been defined and the
+    # arity of method calls.
+    #
+    # In all other ways this behaves like a normal proxy. It only adds the
+    # verification behaviour to specific methods then delegates to the parent
+    # implementation.
+    #
+    # These checks are only activated if the doubled class has already been
+    # loaded, otherwise they are disabled. This allows for testing in
+    # isolation.
+    #
+    # @api private
+    class VerifyingProxy < Proxy
+      include VerifyingProxyMethods
+
+      def initialize(object, order_group, name, method_reference_class)
+        super(object, order_group)
+        @object                 = object
+        @doubled_module         = name
+        @method_reference_class = method_reference_class
+
+        # A custom method double is required to pass through a way to lookup
+        # methods to determine their arity. This is only relevant if the doubled
+        # class is loaded.
+        @method_doubles = Hash.new do |h, k|
+          h[k] = VerifyingMethodDouble.new(@object, k, self, method_reference[k])
+        end
+      end
+
+      def method_reference
+        @method_reference ||= Hash.new do |h, k|
+          h[k] = @method_reference_class.new(@doubled_module, k)
+        end
+      end
+    end
+
+    class VerifyingPartialMockProxy < PartialMockProxy
+      include VerifyingProxyMethods
+
+      def initialize(object, expectation_ordering)
+        super(object, expectation_ordering)
+        @doubled_module = DirectObjectReference.new(object)
+
+        # A custom method double is required to pass through a way to lookup
+        # methods to determine their arity.
+        @method_doubles = Hash.new do |h, k|
+          h[k] = VerifyingExistingMethodDouble.new(object, k, self)
+        end
+      end
+
+      def method_reference
+        @method_doubles
+      end
+    end
+
+    # @api private
+    class VerifyingMethodDouble < MethodDouble
+      def initialize(object, method_name, proxy, method_reference)
+        super(object, method_name, proxy)
+        @method_reference = method_reference
+      end
+
+      def message_expectation_class
+        VerifyingMessageExpectation
+      end
+
+      def add_expectation(*arg)
+        super.tap { |x| x.method_reference = @method_reference }
+      end
+
+      def proxy_method_invoked(obj, *args, &block)
+        ensure_arity!(args.length)
+        super
+      end
+
+    private
+
+      def ensure_arity!(arity)
+        @method_reference.when_defined do |method|
+          calculator = ArityCalculator.new(method)
+          unless calculator.within_range?(arity)
+            raise ArgumentError, "wrong number of arguments (#{arity} for #{method.arity})"
+          end
+        end
+      end
+    end
+
+    # @api private
+    #
+    # A VerifyingMethodDouble fetches the method to verify against from the
+    # original object, using a MethodReference. This works for pure doubles,
+    # but when the original object is itself the one being modified we need to
+    # collapse the reference and the method double into a single object so that
+    # we can access the original pristine method definition.
+    class VerifyingExistingMethodDouble < VerifyingMethodDouble
+      def initialize(object, method_name, proxy)
+        super(object, method_name, proxy, self)
+
+        @valid_method = object.respond_to?(method_name)
+
+        # Trigger an eager find of the original method since if we find it any
+        # later we end up getting a stubbed method with incorrect arity.
+        save_original_method!
+      end
+
+      def when_defined
+        yield original_method
+      end
+
+      def when_unimplemented
+        yield unless @valid_method
+      end
+    end
+  end
+end