opal-rspec 0.4.3 → 0.5.0.beta1

data/{vendor_lib → rspec-mocks/lib}/rspec/mocks/configuration.rb

@@ -2,7 +2,6 @@ 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
@@ -14,9 +13,19 @@ module RSpec
         @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
+      # Sets whether or not RSpec will yield the receiving instance of a
+      # message to blocks that are used for any_instance stub implementations.
+      # When set, the first yielded argument will be the receiving instance.
+      # Defaults to `true`.
+      #
+      # @example
+      #
+      #   RSpec.configure do |rspec|
+      #     rspec.mock_with :rspec do |mocks|
+      #       mocks.yield_receiver_to_any_instance_implementation_blocks = false
+      #     end
+      #   end
+      attr_writer :yield_receiver_to_any_instance_implementation_blocks
 
       # Adds `stub` and `should_receive` to the given
       # modules or classes. This is usually only necessary
@@ -39,20 +48,44 @@ module RSpec
         end
       end
 
-      def syntax=(values)
-        if Array(values).include?(:expect)
+      # Provides the ability to set either `expect`,
+      # `should` or both syntaxes. RSpec uses `expect`
+      # syntax by default. This is needed if you want to
+      # explicitly enable `should` syntax and/or explicitly
+      # disable `expect` syntax.
+      #
+      # @example
+      #
+      #   RSpec.configure do |rspec|
+      #     rspec.mock_with :rspec do |mocks|
+      #       mocks.syntax = [:expect, :should]
+      #     end
+      #  end
+      #
+      def syntax=(*values)
+        syntaxes = values.flatten
+        if syntaxes.include?(:expect)
           Syntax.enable_expect
         else
           Syntax.disable_expect
         end
 
-        if Array(values).include?(:should)
+        if syntaxes.include?(:should)
           Syntax.enable_should
         else
           Syntax.disable_should
         end
       end
 
+      # Returns an array with a list of syntaxes
+      # that are enabled.
+      #
+      # @example
+      #
+      #   unless RSpec::Mocks.configuration.syntax.include?(:expect)
+      #     raise "this RSpec extension gem requires the rspec-mocks `:expect` syntax"
+      #   end
+      #
       def syntax
         syntaxes = []
         syntaxes << :should  if Syntax.should_enabled?
@@ -69,9 +102,7 @@ module RSpec
       # 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
+      attr_writer :verify_doubled_constant_names
 
       def transfer_nested_constants?
         !!@transfer_nested_constants
@@ -79,12 +110,10 @@ module RSpec
 
       # Sets the default for the `transfer_nested_constants` option when
       # stubbing constants.
-      def transfer_nested_constants=(val)
-        @transfer_nested_constants = val
-      end
+      attr_writer :transfer_nested_constants
 
       # When set to true, partial mocks will be verified the same as object
-      # doubles. Any stubs will have their arity checked against the original
+      # doubles. Any stubs will have their arguments checked against the original
       # method, and methods that do not exist cannot be stubbed.
       def verify_partial_doubles=(val)
         @verify_partial_doubles = !!val
@@ -94,6 +123,21 @@ module RSpec
         @verify_partial_doubles
       end
 
+      # Monkey-patch `Marshal.dump` to enable dumping of mocked or stubbed
+      # objects. By default this will not work since RSpec mocks works by
+      # adding singleton methods that cannot be serialized. This patch removes
+      # these singleton methods before serialization. Setting to falsey removes
+      # the patch.
+      #
+      # This method is idempotent.
+      def patch_marshal_to_support_partial_doubles=(val)
+        if val
+          RSpec::Mocks::MarshalExtension.patch!
+        else
+          RSpec::Mocks::MarshalExtension.unpatch!
+        end
+      end
+
       # @api private
       # Resets the configured syntax to the default.
       def reset_syntaxes_to_default
@@ -102,6 +146,8 @@ module RSpec
       end
     end
 
+    # Mocks specific configuration, as distinct from `RSpec.configuration`
+    # which is core RSpec configuration.
     def self.configuration
       @configuration ||= Configuration.new
     end

data/{vendor_lib → rspec-mocks/lib}/rspec/mocks/error_generator.rb

@@ -1,5 +1,22 @@
 module RSpec
   module Mocks
+    # Raised when a message expectation is not satisfied.
+    MockExpectationError = Class.new(Exception)
+
+    # Raised when a test double is used after it has been torn
+    # down (typically at the end of an rspec-core example).
+    ExpiredTestDoubleError = Class.new(MockExpectationError)
+
+    # Raised when doubles or partial doubles are used outside of the per-test lifecycle.
+    OutsideOfExampleError = Class.new(StandardError)
+
+    # @private
+    UnsupportedMatcherError  = Class.new(StandardError)
+    # @private
+    NegationUnsupportedError = Class.new(StandardError)
+    # @private
+    VerifyingDoubleNotDefinedError = Class.new(StandardError)
+
     # @private
     class ErrorGenerator
       attr_writer :opts
@@ -23,76 +40,110 @@ module RSpec
       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}"
+        __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"
+        __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}"
+        actual_args = args_for_multiple_calls.map { |a| format_received_args(*a) }.join(", ")
+        __raise "#{intro} received #{expectation.message.inspect} with " \
+                "unexpected arguments\n  expected: #{expected_args}\n" \
+                "       got: #{actual_args}"
       end
 
+      # rubocop:disable Style/ParameterLists
       # @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
+      # rubocop:enable Style/ParameterLists
 
       # @private
       def raise_unimplemented_error(doubled_module, method_name)
-        __raise "%s does not implement:\n  %s" % [
+        __raise "%s does not implement: %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
+      def raise_non_public_error(method_name, visibility)
+        raise NoMethodError, "%s method `%s' called on %s" % [
+          visibility, method_name, intro
         ]
       end
 
+      # @private
+      def raise_invalid_arguments_error(verifier)
+        __raise verifier.error_message
+      end
+
+      # @private
+      def raise_expired_test_double_error
+        raise ExpiredTestDoubleError,
+              "#{intro} was originally created in one example but has leaked into " \
+              "another example and can no longer be used. rspec-mocks' doubles are " \
+              "designed to only last for one example, and you need to create a new " \
+              "one in each example you wish to use it for."
+      end
+
       # @private
       def received_part_of_expectation_error(actual_received_count, *args)
         "received: #{count_message(actual_received_count)}" +
-          method_call_args_description(args)
+          actual_method_call_args_description(actual_received_count, 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)
+          expected_method_call_args_description(argument_list_matcher.expected_args)
+      end
+
+      # @private
+      def actual_method_call_args_description(count, args)
+        method_call_args_description(args) ||
+          if count > 0 && args.length > 0
+            " with arguments: #{args.inspect.gsub(/\A\[(.+)\]\z/, '(\1)')}"
+          else
+            ""
+          end
+      end
+
+      # @private
+      def expected_method_call_args_description(args)
+        method_call_args_description(args) ||
+          if args.length > 0
+            " with arguments: #{format_args(*args)}"
+          else
+            ""
+          end
       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
-          ""
+        when ArgumentMatchers::AnyArgsMatcher then " with any arguments"
+        when ArgumentMatchers::NoArgsMatcher  then " with no arguments"
         end
       end
 
       # @private
-      def describe_expectation(message, expected_received_count, actual_received_count, *args)
+      def describe_expectation(message, expected_received_count, _actual_received_count, *args)
         "have received #{message}#{format_args(*args)} #{count_message(expected_received_count)}"
       end
 
@@ -112,36 +163,36 @@ module RSpec
       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}"
+      def raise_wrong_arity_error(args_to_yield, signature)
+        __raise "#{intro} yielded |#{arg_list(*args_to_yield)}| to block with #{signature.description}"
       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."
+      def raise_only_valid_on_a_partial_double(method)
+        __raise "#{intro} is a pure test double. `#{method}` is only " \
+                "available on a partial double."
       end
 
       # @private
       def raise_expectation_on_unstubbed_method(method)
-        __raise "#{intro} expected to have received #{method}, but that " +
-                "method has not been stubbed."
+        __raise "#{intro} expected to have received #{method}, but that " \
+                "object is not a spy or 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."
+        __raise "#{intro} expected to have received #{method}, but that " \
+                "method has been mocked instead of stubbed or spied."
       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 " +
+        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
+    private
 
       def intro
         if @name
@@ -159,7 +210,7 @@ module RSpec
 
       def __raise(message)
         message = opts[:message] unless opts[:message].nil?
-        Kernel::raise(RSpec::Mocks::MockExpectationError, message)
+        Kernel.raise(RSpec::Mocks::MockExpectationError, message)
       end
 
       def arg_message(*args)
@@ -171,7 +222,7 @@ module RSpec
       end
 
       def arg_list(*args)
-        args.collect {|arg| arg_has_valid_description(arg) ? arg.description : arg.inspect }.join(", ")
+        args.map { |arg| arg_has_valid_description(arg) ? arg.description : arg.inspect }.join(", ")
       end
 
       def arg_has_valid_description(arg)
@@ -185,19 +236,18 @@ module RSpec
       end
 
       def received_arg_list(*args)
-        args.collect(&:inspect).join(", ")
+        args.map(&: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)
+        return "at least #{times(count.abs)}" if count < 0 || expectation_count_type == :at_least
+        return "at most #{times(count)}" if expectation_count_type == :at_most
+        times(count)
       end
 
-      def pretty_print(count)
+      def times(count)
         "#{count} time#{count == 1 ? '' : 's'}"
       end
-
     end
   end
 end