opal-rspec 0.4.0.beta3 → 0.4.0.beta4

data/vendor_lib/rspec/mocks/syntax.rb

@@ -0,0 +1,374 @@
+module RSpec
+  module Mocks
+    # @api private
+    # Provides methods for enabling and disabling the available syntaxes
+    # provided by rspec-mocks.
+    module Syntax
+      # @api private
+      def self.warn_about_should!
+        @warn_about_should = true
+      end
+
+      # @api private
+      def self.warn_unless_should_configured(method_name)
+        if @warn_about_should
+          RSpec.deprecate(
+            "Using `#{method_name}` from rspec-mocks' old `:should` syntax without explicitly enabling the syntax",
+            :replacement => "the new `:expect` syntax or explicitly enable `:should`"
+          )
+
+          @warn_about_should = false
+        end
+      end
+
+      # @api private
+      # Enables the should syntax (`dbl.stub`, `dbl.should_receive`, etc).
+      def self.enable_should(syntax_host = default_should_syntax_host)
+        @warn_about_should = false
+        return if should_enabled?(syntax_host)
+
+        syntax_host.class_exec do
+          def should_receive(message, opts={}, &block)
+            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
+            opts[:expected_from] ||= CallerFilter.first_non_rspec_line
+            ::RSpec::Mocks.expect_message(self, message, opts, &block)
+          end
+
+          def should_not_receive(message, &block)
+            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
+            opts = {:expected_from => CallerFilter.first_non_rspec_line}
+            ::RSpec::Mocks.expect_message(self, message, opts, &block).never
+          end
+
+          def stub(message_or_hash, opts={}, &block)
+            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
+            if ::Hash === message_or_hash
+              message_or_hash.each {|message, value| stub(message).and_return value }
+            else
+              opts[:expected_from] = CallerFilter.first_non_rspec_line
+              ::RSpec::Mocks.allow_message(self, message_or_hash, opts, &block)
+            end
+          end
+
+          def unstub(message)
+            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
+            ::RSpec::Mocks.space.proxy_for(self).remove_stub(message)
+          end
+
+          def stub_chain(*chain, &blk)
+            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
+            ::RSpec::Mocks::StubChain.stub_chain_on(self, *chain, &blk)
+          end
+
+          def as_null_object
+            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
+            @_null_object = true
+            ::RSpec::Mocks.proxy_for(self).as_null_object
+          end
+
+          def null_object?
+            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
+            defined?(@_null_object)
+          end
+
+          def received_message?(message, *args, &block)
+            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
+            ::RSpec::Mocks.proxy_for(self).received_message?(message, *args, &block)
+          end
+
+          unless Class.respond_to? :any_instance
+            Class.class_exec do
+              def any_instance
+                ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
+                ::RSpec::Mocks.any_instance_recorder_for(self)
+              end
+            end
+          end
+        end
+      end
+
+      # @api private
+      # Disables the should syntax (`dbl.stub`, `dbl.should_receive`, etc).
+      def self.disable_should(syntax_host = default_should_syntax_host)
+        return unless should_enabled?(syntax_host)
+
+        syntax_host.class_exec do
+          undef should_receive
+          undef should_not_receive
+          undef stub
+          undef unstub
+          undef stub_chain
+          undef as_null_object
+          undef null_object?
+          undef received_message?
+        end
+
+        Class.class_exec do
+          undef any_instance
+        end
+      end
+
+      # @api private
+      # Enables the expect syntax (`expect(dbl).to receive`, `allow(dbl).to receive`, etc).
+      def self.enable_expect(syntax_host = ::RSpec::Mocks::ExampleMethods)
+        return if expect_enabled?(syntax_host)
+
+        syntax_host.class_exec do
+          def receive(method_name, &block)
+            Matchers::Receive.new(method_name, block)
+          end
+
+          def receive_messages(message_return_value_hash)
+            matcher = Matchers::ReceiveMessages.new(message_return_value_hash)
+            matcher.warn_about_block if block_given?
+            matcher
+          end
+
+          def allow(target)
+            AllowanceTarget.new(target)
+          end
+
+          def expect_any_instance_of(klass)
+            AnyInstanceExpectationTarget.new(klass)
+          end
+
+          def allow_any_instance_of(klass)
+            AnyInstanceAllowanceTarget.new(klass)
+          end
+        end
+
+        RSpec::Mocks::ExampleMethods::ExpectHost.class_exec do
+          def expect(target)
+            ExpectationTarget.new(target)
+          end
+        end
+      end
+
+      # @api private
+      # Disables the expect syntax (`expect(dbl).to receive`, `allow(dbl).to receive`, etc).
+      def self.disable_expect(syntax_host = ::RSpec::Mocks::ExampleMethods)
+        return unless expect_enabled?(syntax_host)
+
+        syntax_host.class_exec do
+          undef receive
+          undef receive_messages
+          undef allow
+          undef expect_any_instance_of
+          undef allow_any_instance_of
+        end
+
+        RSpec::Mocks::ExampleMethods::ExpectHost.class_exec do
+          undef expect
+        end
+      end
+
+      # @api private
+      # Indicates whether or not the should syntax is enabled.
+      def self.should_enabled?(syntax_host = default_should_syntax_host)
+        syntax_host.method_defined?(:should_receive)
+      end
+
+      # @api private
+      # Indicates whether or not the expect syntax is enabled.
+      def self.expect_enabled?(syntax_host = ::RSpec::Mocks::ExampleMethods)
+        syntax_host.method_defined?(:allow)
+      end
+
+      # @api private
+      # Determines where the methods like `should_receive`, and `stub` are added.
+      def self.default_should_syntax_host
+        # JRuby 1.7.4 introduces a regression whereby `defined?(::BasicObject) => nil`
+        # yet `BasicObject` still exists and patching onto ::Object breaks things
+        # e.g. SimpleDelegator expectations won't work
+        #
+        # See: https://github.com/jruby/jruby/issues/814
+        if defined?(JRUBY_VERSION) && JRUBY_VERSION == '1.7.4' && RUBY_VERSION.to_f > 1.8
+          return ::BasicObject
+        end
+
+        # On 1.8.7, Object.ancestors.last == Kernel but
+        # things blow up if we include `RSpec::Mocks::Methods`
+        # into Kernel...not sure why.
+        return Object unless defined?(::BasicObject)
+
+        # MacRuby has BasicObject but it's not the root class.
+        return Object unless Object.ancestors.last == ::BasicObject
+
+        ::BasicObject
+      end
+
+      # @method should_receive
+      # Sets an expectation that this object should receive a message before
+      # the end of the example.
+      #
+      # @example
+      #
+      #     logger = double('logger')
+      #     thing_that_logs = ThingThatLogs.new(logger)
+      #     logger.should_receive(:log)
+      #     thing_that_logs.do_something_that_logs_a_message
+      #
+      # @note This is only available when you have enabled the `should` syntax.
+
+      # @method should_not_receive
+      # Sets and expectation that this object should _not_ receive a message
+      # during this example.
+
+      # @method stub
+      # Tells the object to respond to the message with the specified value.
+      #
+      # @example
+      #
+      #     counter.stub(:count).and_return(37)
+      #     counter.stub(:count => 37)
+      #     counter.stub(:count) { 37 }
+      #
+      # @note This is only available when you have enabled the `should` syntax.
+
+      # @method unstub
+      # Removes a stub. On a double, the object will no longer respond to
+      # `message`. On a real object, the original method (if it exists) is
+      # restored.
+      #
+      # This is rarely used, but can be useful when a stub is set up during a
+      # shared `before` hook for the common case, but you want to replace it
+      # for a special case.
+      #
+      # @note This is only available when you have enabled the `should` syntax.
+
+      # @method stub_chain
+      # @overload stub_chain(method1, method2)
+      # @overload stub_chain("method1.method2")
+      # @overload stub_chain(method1, method_to_value_hash)
+      #
+      # Stubs a chain of methods.
+      #
+      # ## Warning:
+      #
+      # Chains can be arbitrarily long, which makes it quite painless to
+      # violate the Law of Demeter in violent ways, so you should consider any
+      # use of `stub_chain` a code smell. Even though not all code smells
+      # indicate real problems (think fluent interfaces), `stub_chain` still
+      # results in brittle examples.  For example, if you write
+      # `foo.stub_chain(:bar, :baz => 37)` in a spec and then the
+      # implementation calls `foo.baz.bar`, the stub will not work.
+      #
+      # @example
+      #
+      #     double.stub_chain("foo.bar") { :baz }
+      #     double.stub_chain(:foo, :bar => :baz)
+      #     double.stub_chain(:foo, :bar) { :baz }
+      #
+      #     # Given any of ^^ these three forms ^^:
+      #     double.foo.bar # => :baz
+      #
+      #     # Common use in Rails/ActiveRecord:
+      #     Article.stub_chain("recent.published") { [Article.new] }
+      #
+      # @note This is only available when you have enabled the `should` syntax.
+
+      # @method as_null_object
+      # 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.
+      #
+      # @note This is only available when you have enabled the `should` syntax.
+
+      # @method null_object?
+      # Returns true if this object has received `as_null_object`
+      #
+      # @note This is only available when you have enabled the `should` syntax.
+
+      # @method any_instance
+      # Used to set stubs and message expectations on any instance of a given
+      # class. Returns a [Recorder](Recorder), which records messages like
+      # `stub` and `should_receive` for later playback on instances of the
+      # class.
+      #
+      # @example
+      #
+      #     Car.any_instance.should_receive(:go)
+      #     race = Race.new
+      #     race.cars << Car.new
+      #     race.go # assuming this delegates to all of its cars
+      #             # this example would pass
+      #
+      #     Account.any_instance.stub(:balance) { Money.new(:USD, 25) }
+      #     Account.new.balance # => Money.new(:USD, 25))
+      #
+      # @return [Recorder]
+      #
+      # @note This is only available when you have enabled the `should` syntax.
+
+      # @method expect
+      # Used to wrap an object in preparation for setting a mock expectation
+      # on it.
+      #
+      # @example
+      #
+      #   expect(obj).to receive(:foo).with(5).and_return(:return_value)
+      #
+      # @note This method is usually provided by rspec-expectations, unless
+      #   you are using rspec-mocks w/o rspec-expectations, in which case it
+      #   is only made available if you enable the `expect` syntax.
+
+      # @method allow
+      # Used to wrap an object in preparation for stubbing a method
+      # on it.
+      #
+      # @example
+      #
+      #   allow(dbl).to receive(:foo).with(5).and_return(:return_value)
+      #
+      # @note This is only available when you have enabled the `expect` syntax.
+
+      # @method expect_any_instance_of
+      # Used to wrap a class in preparation for setting a mock expectation
+      # on instances of it.
+      #
+      # @example
+      #
+      #   expect_any_instance_of(MyClass).to receive(:foo)
+      #
+      # @note This is only available when you have enabled the `expect` syntax.
+
+      # @method allow_any_instance_of
+      # Used to wrap a class in preparation for stubbing a method
+      # on instances of it.
+      #
+      # @example
+      #
+      #   allow_any_instance_of(MyClass).to receive(:foo)
+      #
+      # @note This is only available when you have enabled the `expect` syntax.
+
+      # @method receive
+      # Used to specify a message that you expect or allow an object
+      # to receive. The object returned by `receive` supports the same
+      # fluent interface that `should_receive` and `stub` have always
+      # supported, allowing you to constrain the arguments or number of
+      # times, and configure how the object should respond to the message.
+      #
+      # @example
+      #
+      #   expect(obj).to receive(:hello).with("world").exactly(3).times
+      #
+      # @note This is only available when you have enabled the `expect` syntax.
+      #
+      # @method receive_messages
+      # Shorthand syntax used to setup message(s), and their return value(s),
+      # that you expect or allow an object to receive. The method takes a hash
+      # of messages and their respective return values. Unlike with `receive`,
+      # you cannot apply further customizations using a block or the fluent
+      # interface.
+      #
+      # @example
+      #
+      #   allow(obj).to receive_messages(:speak => "Hello World")
+      #   allow(obj).to receive_messages(:speak => "Hello", :meow => "Meow")
+      #
+      # @note This is only available when you have enabled the `expect` syntax.
+    end
+  end
+end
+

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
+