opal-rspec 0.4.0.beta3 → 0.4.0.beta4

data/vendor_lib/rspec/mocks/argument_matchers.rb

@@ -0,0 +1,264 @@
+module RSpec
+  module Mocks
+
+    # ArgumentMatchers are placeholders that you can include in message
+    # expectations to match arguments against a broader check than simple
+    # equality.
+    #
+    # With the exception of `any_args` and `no_args`, they all match against
+    # the arg in same position in the argument list.
+    #
+    # @see ArgumentListMatcher
+    module ArgumentMatchers
+
+      class AnyArgsMatcher
+        def description
+          "any args"
+        end
+      end
+
+      class AnyArgMatcher
+        def initialize(ignore)
+        end
+
+        def ==(other)
+          true
+        end
+      end
+
+      class NoArgsMatcher
+        def description
+          "no args"
+        end
+      end
+
+      class RegexpMatcher
+        def initialize(regexp)
+          @regexp = regexp
+        end
+
+        def ==(value)
+          Regexp === value ? value == @regexp : value =~ @regexp
+        end
+      end
+
+      class BooleanMatcher
+        def initialize(ignore)
+        end
+
+        def ==(value)
+          [true,false].include?(value)
+        end
+      end
+
+      class HashIncludingMatcher
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def ==(actual)
+          @expected.all? {|k,v| actual.has_key?(k) && v == actual[k]}
+        rescue NoMethodError
+          false
+        end
+
+        def description
+          "hash_including(#{@expected.inspect.sub(/^\{/,"").sub(/\}$/,"")})"
+        end
+      end
+
+      class HashExcludingMatcher
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def ==(actual)
+          @expected.none? {|k,v| actual.has_key?(k) && v == actual[k]}
+        rescue NoMethodError
+          false
+        end
+
+        def description
+          "hash_not_including(#{@expected.inspect.sub(/^\{/,"").sub(/\}$/,"")})"
+        end
+      end
+
+      class ArrayIncludingMatcher
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def ==(actual)
+          Set.new(actual).superset?(Set.new(@expected))
+        end
+
+        def description
+          "array_including(#{@expected.join(",")})"
+        end
+      end
+
+      class DuckTypeMatcher
+        def initialize(*methods_to_respond_to)
+          @methods_to_respond_to = methods_to_respond_to
+        end
+
+        def ==(value)
+          @methods_to_respond_to.all? {|message| value.respond_to?(message)}
+        end
+      end
+
+      class MatcherMatcher
+        def initialize(matcher)
+          @matcher = matcher
+        end
+
+        def ==(value)
+          @matcher.matches?(value)
+        end
+      end
+
+      class EqualityProxy
+        def initialize(given)
+          @given = given
+        end
+
+        def ==(expected)
+          @given == expected
+        end
+      end
+
+      class InstanceOf
+        def initialize(klass)
+          @klass = klass
+        end
+
+        def ==(actual)
+          actual.instance_of?(@klass)
+        end
+      end
+
+      class KindOf
+        def initialize(klass)
+          @klass = klass
+        end
+
+        def ==(actual)
+          actual.kind_of?(@klass)
+        end
+      end
+
+      # Matches any args at all. Supports a more explicit variation of
+      # `object.should_receive(:message)`
+      #
+      # @example
+      #
+      #   object.should_receive(:message).with(any_args)
+      def any_args
+        AnyArgsMatcher.new
+      end
+
+      # Matches any argument at all.
+      #
+      # @example
+      #
+      #   object.should_receive(:message).with(anything)
+      def anything
+        AnyArgMatcher.new(nil)
+      end
+
+      # Matches no arguments.
+      #
+      # @example
+      #
+      #   object.should_receive(:message).with(no_args)
+      def no_args
+        NoArgsMatcher.new
+      end
+
+      # Matches if the actual argument responds to the specified messages.
+      #
+      # @example
+      #
+      #   object.should_receive(:message).with(duck_type(:hello))
+      #   object.should_receive(:message).with(duck_type(:hello, :goodbye))
+      def duck_type(*args)
+        DuckTypeMatcher.new(*args)
+      end
+
+      # Matches a boolean value.
+      #
+      # @example
+      #
+      #   object.should_receive(:message).with(boolean())
+      def boolean
+        BooleanMatcher.new(nil)
+      end
+
+      # Matches a hash that includes the specified key(s) or key/value pairs.
+      # Ignores any additional keys.
+      #
+      # @example
+      #
+      #   object.should_receive(:message).with(hash_including(:key => val))
+      #   object.should_receive(:message).with(hash_including(:key))
+      #   object.should_receive(:message).with(hash_including(:key, :key2 => val2))
+      def hash_including(*args)
+        HashIncludingMatcher.new(anythingize_lonely_keys(*args))
+      end
+
+      # Matches an array that includes the specified items at least once.
+      # Ignores duplicates and additional values
+      #
+      # @example
+      #
+      #   object.should_receive(:message).with(array_including(1,2,3))
+      #   object.should_receive(:message).with(array_including([1,2,3]))
+      def array_including(*args)
+        actually_an_array = Array === args.first && args.count == 1 ? args.first : args
+        ArrayIncludingMatcher.new(actually_an_array)
+      end
+
+      # Matches a hash that doesn't include the specified key(s) or key/value.
+      #
+      # @example
+      #
+      #   object.should_receive(:message).with(hash_excluding(:key => val))
+      #   object.should_receive(:message).with(hash_excluding(:key))
+      #   object.should_receive(:message).with(hash_excluding(:key, :key2 => :val2))
+      def hash_excluding(*args)
+        HashExcludingMatcher.new(anythingize_lonely_keys(*args))
+      end
+
+      alias_method :hash_not_including, :hash_excluding
+
+      # Matches if `arg.instance_of?(klass)`
+      #
+      # @example
+      #
+      #   object.should_receive(:message).with(instance_of(Thing))
+      def instance_of(klass)
+        InstanceOf.new(klass)
+      end
+
+      alias_method :an_instance_of, :instance_of
+
+      # Matches if `arg.kind_of?(klass)`
+      # @example
+      #
+      #   object.should_receive(:message).with(kind_of(Thing))
+      def kind_of(klass)
+        KindOf.new(klass)
+      end
+
+      alias_method :a_kind_of, :kind_of
+
+      private
+
+      def anythingize_lonely_keys(*args)
+        hash = args.last.class == Hash ? args.delete_at(-1) : {}
+        args.each { | arg | hash[arg] = anything }
+        hash
+      end
+    end
+  end
+end

data/vendor_lib/rspec/mocks/arity_calculator.rb

@@ -0,0 +1,66 @@
+module RSpec
+  module Mocks
+
+    # Figures out the valid arity range for a method. Surprisingly non-trivial.
+    class ArityCalculator
+
+      def initialize(method)
+        @method = method
+      end
+
+      # @api private
+      def within_range?(actual)
+        min_arity <= actual && actual <= max_arity
+      end
+
+      # @api private
+      def range_description
+        return min_arity.to_s if min_arity == max_arity
+        return "#{min_arity} or more" if max_arity == INFINITY
+        "#{min_arity} to #{max_arity}"
+      end
+
+      private
+
+      def method
+        @method
+      end
+
+      # @api private
+      def self.supports_optional_and_splat_args?
+        Method.method_defined?(:parameters)
+      end
+
+      def min_arity
+        return method.arity if method.arity >= 0
+        # `~` inverts the one's complement and gives us the number of
+        # required arguments.
+        ~method.arity
+      end
+
+      if supports_optional_and_splat_args?
+        def max_arity
+          params = method.parameters
+          if params.any? {|(type, _)| type == :rest }
+            # Method takes a splat argument
+            return INFINITY
+          else
+            params.count {|(type, _)| type != :block }
+          end
+        end
+      else
+        def max_arity
+          # On 1.8, Method#parameters does not exist.  There is no way to
+          # distinguish between default and splat args, so there is no way to
+          # have it work correctly for both default and splat args, as far as I
+          # can tell. The best we can do is consider it INFINITY (to be
+          # tolerant of splat args).
+          method.arity < 0 ? INFINITY : method.arity
+        end
+      end
+
+      INFINITY = 1/0.0
+    end
+  end
+end
+

data/vendor_lib/rspec/mocks/configuration.rb

@@ -0,0 +1,111 @@
+module RSpec
+  module Mocks
+    # Provides configuration options for rspec-mocks.
+    class Configuration
+
+      def initialize
+        @yield_receiver_to_any_instance_implementation_blocks = true
+        @verify_doubled_constant_names = false
+        @transfer_nested_constants = false
+        @verify_partial_doubles = false
+      end
+
+      def yield_receiver_to_any_instance_implementation_blocks?
+        @yield_receiver_to_any_instance_implementation_blocks
+      end
+
+      def yield_receiver_to_any_instance_implementation_blocks=(arg)
+        @yield_receiver_to_any_instance_implementation_blocks = arg
+      end
+
+      # Adds `stub` and `should_receive` to the given
+      # modules or classes. This is usually only necessary
+      # if you application uses some proxy classes that
+      # "strip themselves down" to a bare minimum set of
+      # methods and remove `stub` and `should_receive` in
+      # the process.
+      #
+      # @example
+      #
+      #   RSpec.configure do |rspec|
+      #     rspec.mock_with :rspec do |mocks|
+      #       mocks.add_stub_and_should_receive_to Delegator
+      #     end
+      #   end
+      #
+      def add_stub_and_should_receive_to(*modules)
+        modules.each do |mod|
+          Syntax.enable_should(mod)
+        end
+      end
+
+      def syntax=(values)
+        if Array(values).include?(:expect)
+          Syntax.enable_expect
+        else
+          Syntax.disable_expect
+        end
+
+        if Array(values).include?(:should)
+          Syntax.enable_should
+        else
+          Syntax.disable_should
+        end
+      end
+
+      def syntax
+        syntaxes = []
+        syntaxes << :should  if Syntax.should_enabled?
+        syntaxes << :expect if Syntax.expect_enabled?
+        syntaxes
+      end
+
+      def verify_doubled_constant_names?
+        !!@verify_doubled_constant_names
+      end
+
+      # When this is set to true, an error will be raised when
+      # `instance_double` or `class_double` is given the name of an undefined
+      # constant. You probably only want to set this when running your entire
+      # test suite, with all production code loaded. Setting this for an
+      # isolated unit test will prevent you from being able to isolate it!
+      def verify_doubled_constant_names=(val)
+        @verify_doubled_constant_names = val
+      end
+
+      def transfer_nested_constants?
+        !!@transfer_nested_constants
+      end
+
+      # Sets the default for the `transfer_nested_constants` option when
+      # stubbing constants.
+      def transfer_nested_constants=(val)
+        @transfer_nested_constants = val
+      end
+
+      # When set to true, partial mocks will be verified the same as object
+      # doubles. Any stubs will have their arity checked against the original
+      # method, and methods that do not exist cannot be stubbed.
+      def verify_partial_doubles=(val)
+        @verify_partial_doubles = !!val
+      end
+
+      def verify_partial_doubles?
+        @verify_partial_doubles
+      end
+
+      # @api private
+      # Resets the configured syntax to the default.
+      def reset_syntaxes_to_default
+        self.syntax = [:should, :expect]
+        RSpec::Mocks::Syntax.warn_about_should!
+      end
+    end
+
+    def self.configuration
+      @configuration ||= Configuration.new
+    end
+
+    configuration.reset_syntaxes_to_default
+  end
+end

data/vendor_lib/rspec/mocks/error_generator.rb

@@ -0,0 +1,203 @@
+module RSpec
+  module Mocks
+    # @private
+    class ErrorGenerator
+      attr_writer :opts
+
+      def initialize(target, name)
+        @target = target
+        @name = name
+      end
+
+      # @private
+      def opts
+        @opts ||= {}
+      end
+
+      # @private
+      def raise_unexpected_message_error(message, *args)
+        __raise "#{intro} received unexpected message :#{message}#{arg_message(*args)}"
+      end
+
+      # @private
+      def raise_unexpected_message_args_error(expectation, *args)
+        expected_args = format_args(*expectation.expected_args)
+        actual_args = format_received_args(*args)
+        __raise "#{intro} received #{expectation.message.inspect} with unexpected arguments\n  expected: #{expected_args}\n       got: #{actual_args}"
+      end
+
+      # @private
+      def raise_missing_default_stub_error(expectation, *args)
+        expected_args = format_args(*expectation.expected_args)
+        actual_args = format_received_args(*args)
+        __raise "#{intro} received #{expectation.message.inspect} with unexpected arguments\n  expected: #{expected_args}\n       got: #{actual_args}\n Please stub a default value first if message might be received with other args as well. \n"
+      end
+
+      # @private
+      def raise_similar_message_args_error(expectation, *args_for_multiple_calls)
+        expected_args = format_args(*expectation.expected_args)
+        actual_args = args_for_multiple_calls.collect {|a| format_received_args(*a)}.join(", ")
+        __raise "#{intro} received #{expectation.message.inspect} with unexpected arguments\n  expected: #{expected_args}\n       got: #{actual_args}"
+      end
+
+      # @private
+      def raise_expectation_error(message, expected_received_count, argument_list_matcher, actual_received_count, expectation_count_type, *args)
+        expected_part = expected_part_of_expectation_error(expected_received_count, expectation_count_type, argument_list_matcher)
+        received_part = received_part_of_expectation_error(actual_received_count, *args)
+        __raise "(#{intro}).#{message}#{format_args(*args)}\n    #{expected_part}\n    #{received_part}"
+      end
+
+      # @private
+      def raise_unimplemented_error(doubled_module, method_name)
+        __raise "%s does not implement:\n  %s" % [
+          doubled_module.description,
+          method_name
+        ]
+      end
+
+      # @private
+      def raise_arity_error(calculator, actual)
+        __raise "Wrong number of arguments. Expected %s, got %s." % [
+          calculator.range_description,
+          actual
+        ]
+      end
+
+      # @private
+      def received_part_of_expectation_error(actual_received_count, *args)
+        "received: #{count_message(actual_received_count)}" +
+          method_call_args_description(args)
+      end
+
+      # @private
+      def expected_part_of_expectation_error(expected_received_count, expectation_count_type, argument_list_matcher)
+        "expected: #{count_message(expected_received_count, expectation_count_type)}" +
+          method_call_args_description(argument_list_matcher.expected_args)
+      end
+
+      # @private
+      def method_call_args_description(args)
+        case args.first
+          when ArgumentMatchers::AnyArgsMatcher
+            return " with any arguments"
+          when ArgumentMatchers::NoArgsMatcher
+            return " with no arguments"
+        end
+
+        if args.length > 0
+          " with arguments: #{args.inspect.gsub(/\A\[(.+)\]\z/, '(\1)')}"
+        else
+          ""
+        end
+      end
+
+      # @private
+      def describe_expectation(message, expected_received_count, actual_received_count, *args)
+        "have received #{message}#{format_args(*args)} #{count_message(expected_received_count)}"
+      end
+
+      # @private
+      def raise_out_of_order_error(message)
+        __raise "#{intro} received :#{message} out of order"
+      end
+
+      # @private
+      def raise_block_failed_error(message, detail)
+        __raise "#{intro} received :#{message} but passed block failed with: #{detail}"
+      end
+
+      # @private
+      def raise_missing_block_error(args_to_yield)
+        __raise "#{intro} asked to yield |#{arg_list(*args_to_yield)}| but no block was passed"
+      end
+
+      # @private
+      def raise_wrong_arity_error(args_to_yield, arity)
+        __raise "#{intro} yielded |#{arg_list(*args_to_yield)}| to block with arity of #{arity}"
+      end
+
+      # @private
+      def raise_only_valid_on_a_partial_mock(method)
+        __raise "#{intro} is a pure mock object. `#{method}` is only " +
+                "available on a partial mock object."
+      end
+
+      # @private
+      def raise_expectation_on_unstubbed_method(method)
+        __raise "#{intro} expected to have received #{method}, but that " +
+                "method has not been stubbed."
+      end
+
+      # @private
+      def raise_expectation_on_mocked_method(method)
+        __raise "#{intro} expected to have received #{method}, but that " +
+                "method has been mocked instead of stubbed."
+      end
+
+      def self.raise_double_negation_error(wrapped_expression)
+        raise "Isn't life confusing enough? You've already set a " +
+              "negative message expectation and now you are trying to " +
+              "negate it again with `never`. What does an expression like " +
+              "`#{wrapped_expression}.not_to receive(:msg).never` even mean?"
+      end
+
+      private
+
+      def intro
+        if @name
+          "Double #{@name.inspect}"
+        elsif TestDouble === @target
+          "Double"
+        elsif Class === @target
+          "<#{@target.inspect} (class)>"
+        elsif @target
+          @target
+        else
+          "nil"
+        end
+      end
+
+      def __raise(message)
+        message = opts[:message] unless opts[:message].nil?
+        Kernel::raise(RSpec::Mocks::MockExpectationError, message)
+      end
+
+      def arg_message(*args)
+        " with " + format_args(*args)
+      end
+
+      def format_args(*args)
+        args.empty? ? "(no args)" : "(" + arg_list(*args) + ")"
+      end
+
+      def arg_list(*args)
+        args.collect {|arg| arg_has_valid_description(arg) ? arg.description : arg.inspect }.join(", ")
+      end
+
+      def arg_has_valid_description(arg)
+        return false unless arg.respond_to?(:description)
+
+        !arg.description.nil? && !arg.description.empty?
+      end
+
+      def format_received_args(*args)
+        args.empty? ? "(no args)" : "(" + received_arg_list(*args) + ")"
+      end
+
+      def received_arg_list(*args)
+        args.collect(&:inspect).join(", ")
+      end
+
+      def count_message(count, expectation_count_type=nil)
+        return "at least #{pretty_print(count.abs)}" if count < 0 || expectation_count_type == :at_least
+        return "at most #{pretty_print(count)}" if expectation_count_type == :at_most
+        return pretty_print(count)
+      end
+
+      def pretty_print(count)
+        "#{count} time#{count == 1 ? '' : 's'}"
+      end
+
+    end
+  end
+end

data/vendor_lib/rspec/mocks/errors.rb

@@ -0,0 +1,12 @@
+module RSpec
+  module Mocks
+    # @private
+    class MockExpectationError < Exception
+    end
+
+    # @private
+    class AmbiguousReturnError < StandardError
+    end
+  end
+end
+