opal-rspec 0.8.0.alpha3 → 1.0.0.alpha1

data/rspec-mocks/upstream/features/verifying_doubles/instance_doubles.feature

@@ -2,8 +2,10 @@ Feature: Using an instance double
 
   An `instance_double` is the most common type of verifying double. It takes a class name or
   object as its first argument, then verifies that any methods being stubbed would be present
-  on an _instance_ of that class. If any argument matchers are specified, it also verifies that the
-  number of arguments is correct.
+  on an _instance_ of that class. In addition, when it receives messages, it verifies that the
+  provided arguments are supported by the method signature, both in terms of arity and
+  allowed or required keyword arguments, if any. The same argument verification happens
+  when you [constrain the arguments](../setting-constraints/matching-arguments) using `with`.
 
   For methods handled by `method_missing`, see [dynamic classes](./dynamic-classes).
 
@@ -85,7 +87,7 @@ Feature: Using an instance double
       """
     When I run `rspec -r./spec/spec_helper spec/unit/user_spec.rb`
     Then the output should contain "1 example, 1 failure"
-    And the output should contain "ConsoleNotifier does not implement:"
+    And the output should contain "ConsoleNotifier class does not implement the instance method:"
 
   Scenario: spec fails with dependencies loaded and incorrect arity
     Given a file named "app/models/console_notifier.rb" with:

data/rspec-mocks/upstream/features/working_with_legacy_code/any_instance.feature

@@ -11,13 +11,15 @@ Feature: Any Instance
 
   These methods add the appropriate stub or expectation to all instances of `Widget`.
 
+  You can also [configure the responses](../configuring-responses) in the same manner.
+
   This feature is sometimes useful when working with legacy code, though in general we
-  discourage its use for a number of reasons: 
+  discourage its use for a number of reasons:
 
   * The `rspec-mocks` API is designed for individual object instances, but this feature
-    operates on entire classes of objects. As a result there are some sematically confusing
+    operates on entire classes of objects. As a result there are some semantically confusing
     edge cases. For example, in `expect_any_instance_of(Widget).to
-    receive(:name).twice` it isn't clear whether each specific instance is expected to
+    receive(:name).twice` it isn't clear whether a specific instance is expected to
     receive `name` twice, or if two receives total are expected. (It's the former.)
   * Using this feature is often a design smell. It may be that your test is trying to do too
     much or that the object under test is too complex.
@@ -81,11 +83,11 @@ Feature: Any Instance
       """ruby
       RSpec.describe "allow_any_instance_of" do
         it 'yields the receiver to the block implementation' do
-          allow_any_instance_of(Array).to receive(:shuffle) do |array|
-            array.unshift(array.pop)
+          allow_any_instance_of(String).to receive(:slice) do |instance, start, length|
+            instance[start, length]
           end
 
-          expect([1, 2, 3].shuffle).to eq([3, 1, 2])
+          expect('string'.slice(2, 3)).to eq('rin')
         end
       end
       """

data/rspec-mocks/upstream/features/working_with_legacy_code/message_chains.feature

@@ -1,6 +1,7 @@
 Feature: Message Chains
 
-  You can use `receive_message_chain` in place of `receive` to stub a chain of messages:
+  You can use `receive_message_chain` in place of `receive` in certain circumstances
+  to stub a chain of messages:
 
   ```ruby
   allow(double).to receive_message_chain("foo.bar") { :baz }
@@ -20,6 +21,12 @@ Feature: Message Chains
   allow(Article).to receive_message_chain("recent.published") { [Article.new] }
   ```
 
+  `receive_message_chain` is designed to be used with evaluating a response like `and_return`,
+  `and_yield` etc. For legacy reasons, parity with `stub_chain` is supported but its uses are
+  not considered good practice. Support for `stub_chain` parity may be removed in future versions.
+
+  Customisations like `exactly` (i.e. `exactly(2).times`) are not supported.
+
   Warning:
   ========
 
@@ -30,6 +37,14 @@ Feature: Message Chains
   `allow(foo).to receive_message_chain(:bar, :baz => 37)` in a spec and then the
   implementation calls `foo.baz.bar`, the stub will not work.
 
+
+  Chaining with `receive_message_chain` creates ambiguity in how the chains should
+  be applied and applies design pressure on complex interactions in the implementation
+  code. As such `receive_message_chain` is not a perfect replacement for `receive`. (see
+  [Issue 921](https://github.com/rspec/rspec-mocks/issues/921) for a more detailed
+  explanation).  Other mocking methods like `double` and `instance_double` provide a
+  better way of testing code with these interactions.
+
   Scenario: Use `receive_message_chain` on a double
     Given a file named "receive_message_chain_spec.rb" with:
       """ruby

data/rspec-mocks/upstream/lib/rspec/mocks/any_instance/chain.rb

@@ -34,12 +34,14 @@ module RSpec
           record :and_throw
           record :and_yield
           record :and_call_original
+          record :and_wrap_original
           record :with
           record :once
           record :twice
           record :thrice
           record :exactly
           record :times
+          record :time
           record :never
           record :at_least
           record :at_most
@@ -75,7 +77,7 @@ module RSpec
         end
 
         def never
-          ErrorGenerator.raise_double_negation_error("expect_any_instance_of(MyClass)") if negated?
+          AnyInstance.error_generator.raise_double_negation_error("expect_any_instance_of(MyClass)") if negated?
           super
         end
 

data/rspec-mocks/upstream/lib/rspec/mocks/any_instance/error_generator.rb

@@ -0,0 +1,31 @@
+module RSpec
+  module Mocks
+    module AnyInstance
+      # @private
+      class ErrorGenerator < ::RSpec::Mocks::ErrorGenerator
+        def raise_second_instance_received_message_error(unfulfilled_expectations)
+          __raise "Exactly one instance should have received the following " \
+                  "message(s) but didn't: #{unfulfilled_expectations.sort.join(', ')}"
+        end
+
+        def raise_does_not_implement_error(klass, method_name)
+          __raise "#{klass} does not implement ##{method_name}"
+        end
+
+        def raise_message_already_received_by_other_instance_error(method_name, object_inspect, invoked_instance)
+          __raise "The message '#{method_name}' was received by #{object_inspect} " \
+                  "but has already been received by #{invoked_instance}"
+        end
+
+        def raise_not_supported_with_prepend_error(method_name, problem_mod)
+          __raise "Using `any_instance` to stub a method (#{method_name}) that has been " \
+                  "defined on a prepended module (#{problem_mod}) is not supported."
+        end
+      end
+
+      def self.error_generator
+        @error_generator ||= ErrorGenerator.new
+      end
+    end
+  end
+end

data/rspec-mocks/upstream/lib/rspec/mocks/any_instance/expect_chain_chain.rb

@@ -23,11 +23,7 @@ module RSpec
         end
 
         def invocation_order
-          @invocation_order ||= {
-            :and_return => [nil],
-            :and_raise => [nil],
-            :and_yield => [nil]
-          }
+          EmptyInvocationOrder
         end
       end
     end

data/rspec-mocks/upstream/lib/rspec/mocks/any_instance/expectation_chain.rb

@@ -35,12 +35,14 @@ module RSpec
           me
         end
 
-        def invocation_order
-          @invocation_order ||= {
-            :with => [nil],
+        ExpectationInvocationOrder =
+          {
             :and_return => [:with, nil],
-            :and_raise => [:with, nil]
-          }
+            :and_raise => [:with, nil],
+          }.freeze
+
+        def invocation_order
+          ExpectationInvocationOrder
         end
       end
     end

data/rspec-mocks/upstream/lib/rspec/mocks/any_instance/message_chains.rb

@@ -75,9 +75,7 @@ module RSpec
           return unless ExpectationChain === instance
           return if @instance_with_expectation.equal?(instance)
 
-          raise RSpec::Mocks::MockExpectationError,
-                "Exactly one instance should have received the following " \
-                "message(s) but didn't: #{unfulfilled_expectations.sort.join(', ')}"
+          AnyInstance.error_generator.raise_second_instance_received_message_error(unfulfilled_expectations)
         end
       end
     end

data/rspec-mocks/upstream/lib/rspec/mocks/any_instance/recorder.rb

@@ -18,8 +18,14 @@ module RSpec
           @stubs = Hash.new { |hash, key| hash[key] = [] }
           @observed_methods = []
           @played_methods = {}
+          @backed_up_method_owner = {}
           @klass = klass
           @expectation_set = false
+
+          return unless RSpec::Mocks.configuration.verify_partial_doubles?
+          RSpec::Mocks.configuration.verifying_double_callbacks.each do |block|
+            block.call(ObjectReference.for(klass))
+          end
         end
 
         # Initializes the recording a stub to be played back against any
@@ -76,7 +82,7 @@ module RSpec
         # @see Methods#unstub
         def unstub(method_name)
           unless @observed_methods.include?(method_name.to_sym)
-            raise RSpec::Mocks::MockExpectationError, "The method `#{method_name}` was not stubbed or was already unstubbed"
+            AnyInstance.error_generator.raise_method_not_stubbed_error(method_name)
           end
           message_chains.remove_stub_chains_for!(method_name)
           stubs[method_name].clear
@@ -91,9 +97,7 @@ module RSpec
           return unless @expectation_set
           return if message_chains.all_expectations_fulfilled?
 
-          raise RSpec::Mocks::MockExpectationError,
-                "Exactly one instance should have received the following " \
-                "message(s) but didn't: #{message_chains.unfulfilled_expectations.sort.join(', ')}"
+          AnyInstance.error_generator.raise_second_instance_received_message_error(message_chains.unfulfilled_expectations)
         end
 
         # @private
@@ -192,9 +196,30 @@ module RSpec
           return unless @klass.instance_method(method_name).owner == @klass
 
           alias_method_name = build_alias_method_name(method_name)
-          @klass.class_exec do
+          @klass.class_exec(@backed_up_method_owner) do |backed_up_method_owner|
             remove_method method_name
-            alias_method method_name, alias_method_name
+
+            # A @klass can have methods implemented (see Method#owner) in @klass
+            # or inherited from a superclass. In ruby 2.2 and earlier, we can copy
+            # a method regardless of the 'owner' and restore it to @klass after
+            # because a call to 'super' from @klass's copied method would end up
+            # calling the original class's superclass's method.
+            #
+            # With the commit below, available starting in 2.3.0, ruby changed
+            # this behavior and a call to 'super' from the method copied to @klass
+            # will call @klass's superclass method, which is the original
+            # implementer of this method!  This leads to very strange errors
+            # if @klass's copied method calls 'super', since it would end up
+            # calling itself, the original method implemented in @klass's
+            # superclass.
+            #
+            # For ruby 2.3 and above, we need to only restore methods that
+            # @klass originally owned.
+            #
+            # https://github.com/ruby/ruby/commit/c8854d2ca4be9ee6946e6d17b0e17d9ef130ee81
+            if RUBY_VERSION < "2.3" || backed_up_method_owner[method_name.to_sym] == self
+              alias_method method_name, alias_method_name
+            end
             remove_method alias_method_name
           end
         end
@@ -206,10 +231,13 @@ module RSpec
         end
 
         def backup_method!(method_name)
+          return unless public_protected_or_private_method_defined?(method_name)
+
           alias_method_name = build_alias_method_name(method_name)
+          @backed_up_method_owner[method_name.to_sym] ||= @klass.instance_method(method_name).owner
           @klass.class_exec do
             alias_method alias_method_name, method_name
-          end if public_protected_or_private_method_defined?(method_name)
+          end
         end
 
         def public_protected_or_private_method_defined?(method_name)
@@ -219,10 +247,9 @@ module RSpec
         def observe!(method_name)
           allow_no_prepended_module_definition_of(method_name)
 
-          if RSpec::Mocks.configuration.verify_partial_doubles?
+          if RSpec::Mocks.configuration.verify_partial_doubles? && !Mocks.configuration.temporarily_suppress_partial_double_verification
             unless public_protected_or_private_method_defined?(method_name)
-              raise MockExpectationError,
-                    "#{@klass} does not implement ##{method_name}"
+              AnyInstance.error_generator.raise_does_not_implement_error(@klass, method_name)
             end
           end
 
@@ -234,6 +261,7 @@ module RSpec
             recorder.playback!(self, method_name)
             __send__(method_name, *args, &blk)
           end
+          @klass.__send__(:ruby2_keywords, method_name) if @klass.respond_to?(:ruby2_keywords, true)
         end
 
         def mark_invoked!(method_name)
@@ -242,7 +270,9 @@ module RSpec
           @klass.__send__(:define_method, method_name) do |*_args, &_blk|
             invoked_instance = recorder.instance_that_received(method_name)
             inspect = "#<#{self.class}:#{object_id} #{instance_variables.map { |name| "#{name}=#{instance_variable_get name}" }.join(', ')}>"
-            raise RSpec::Mocks::MockExpectationError, "The message '#{method_name}' was received by #{inspect} but has already been received by #{invoked_instance}"
+            AnyInstance.error_generator.raise_message_already_received_by_other_instance_error(
+              method_name, inspect, invoked_instance
+            )
           end
         end
 
@@ -252,9 +282,7 @@ module RSpec
             problem_mod = prepended_modules.find { |mod| mod.method_defined?(method_name) }
             return unless problem_mod
 
-            raise RSpec::Mocks::MockExpectationError,
-                  "Using `any_instance` to stub a method (#{method_name}) that has been " \
-                  "defined on a prepended module (#{problem_mod}) is not supported."
+            AnyInstance.error_generator.raise_not_supported_with_prepend_error(method_name, problem_mod)
           end
         else
           def allow_no_prepended_module_definition_of(_method_name)

data/rspec-mocks/upstream/lib/rspec/mocks/any_instance/stub_chain.rb

@@ -25,18 +25,24 @@ module RSpec
           stub
         end
 
-        def invocation_order
-          @invocation_order ||= {
-            :with => [nil],
+        InvocationOrder =
+          {
             :and_return => [:with, nil],
             :and_raise => [:with, nil],
-            :and_yield => [:with, nil],
-            :and_call_original => [:with, nil]
-          }
+            :and_yield => [:with, :and_yield, nil],
+            :and_throw => [:with, nil],
+            :and_call_original => [:with, nil],
+            :and_wrap_original => [:with, nil]
+          }.freeze
+
+        EmptyInvocationOrder = {}.freeze
+
+        def invocation_order
+          InvocationOrder
         end
 
         def verify_invocation_order(rspec_method_name, *_args, &_block)
-          return if invocation_order[rspec_method_name].include?(last_message)
+          return if invocation_order.fetch(rspec_method_name, [nil]).include?(last_message)
           raise NoMethodError, "Undefined method #{rspec_method_name}"
         end
       end

data/rspec-mocks/upstream/lib/rspec/mocks/any_instance/stub_chain_chain.rb

@@ -15,11 +15,7 @@ module RSpec
         end
 
         def invocation_order
-          @invocation_order ||= {
-            :and_return => [nil],
-            :and_raise => [nil],
-            :and_yield => [nil]
-          }
+          EmptyInvocationOrder
         end
       end
     end

data/rspec-mocks/upstream/lib/rspec/mocks/any_instance.rb

@@ -1,5 +1,6 @@
 %w[
   any_instance/chain
+  any_instance/error_generator
   any_instance/stub_chain
   any_instance/stub_chain_chain
   any_instance/expect_chain_chain

data/rspec-mocks/upstream/lib/rspec/mocks/argument_list_matcher.rb

@@ -44,29 +44,72 @@ module RSpec
       # @see #args_match?
       def initialize(*expected_args)
         @expected_args = expected_args
-
-        @matchers = case expected_args.first
-                    when ArgumentMatchers::AnyArgsMatcher then Array
-                    when ArgumentMatchers::NoArgsMatcher  then []
-                    else expected_args
-                    end
+        ensure_expected_args_valid!
       end
+      ruby2_keywords :initialize if respond_to?(:ruby2_keywords, true)
 
       # @api public
-      # @param [Array] args
+      # @param [Array] actual_args
       #
       # Matches each element in the `expected_args` against the element in the same
       # position of the arguments passed to `new`.
       #
       # @see #initialize
-      def args_match?(*args)
-        Support::FuzzyMatcher.values_match?(@matchers, args)
+      def args_match?(*actual_args)
+        expected_args = resolve_expected_args_based_on(actual_args)
+
+        return false if expected_args.size != actual_args.size
+
+        if RUBY_VERSION >= "3"
+          # if both arguments end with Hashes, and if one is a keyword hash and the other is not, they don't match
+          if Hash === expected_args.last && Hash === actual_args.last
+            if !Hash.ruby2_keywords_hash?(actual_args.last) && Hash.ruby2_keywords_hash?(expected_args.last)
+              return false
+            end
+          end
+        end
+
+        Support::FuzzyMatcher.values_match?(expected_args, actual_args)
+      end
+      ruby2_keywords :args_match? if respond_to?(:ruby2_keywords, true)
+
+      # @private
+      # Resolves abstract arg placeholders like `no_args` and `any_args` into
+      # a more concrete arg list based on the provided `actual_args`.
+      def resolve_expected_args_based_on(actual_args)
+        return [] if [ArgumentMatchers::NoArgsMatcher::INSTANCE] == expected_args
+
+        any_args_index = expected_args.index { |a| ArgumentMatchers::AnyArgsMatcher::INSTANCE == a }
+        return expected_args unless any_args_index
+
+        replace_any_args_with_splat_of_anything(any_args_index, actual_args.count)
+      end
+
+    private
+
+      def replace_any_args_with_splat_of_anything(before_count, actual_args_count)
+        any_args_count  = actual_args_count   - expected_args.count + 1
+        after_count     = expected_args.count - before_count        - 1
+
+        any_args = 1.upto(any_args_count).map { ArgumentMatchers::AnyArgMatcher::INSTANCE }
+        expected_args.first(before_count) + any_args + expected_args.last(after_count)
+      end
+
+      def ensure_expected_args_valid!
+        if expected_args.count { |a| ArgumentMatchers::AnyArgsMatcher::INSTANCE == a } > 1
+          raise ArgumentError, "`any_args` can only be passed to " \
+                "`with` once but you have passed it multiple times."
+        elsif expected_args.count > 1 && expected_args.any? { |a| ArgumentMatchers::NoArgsMatcher::INSTANCE == a }
+          raise ArgumentError, "`no_args` can only be passed as a " \
+                "singleton argument to `with` (i.e. `with(no_args)`), " \
+                "but you have passed additional arguments."
+        end
       end
 
       # Value that will match all argument lists.
       #
       # @private
-      MATCH_ALL = new(ArgumentMatchers::AnyArgsMatcher.new)
+      MATCH_ALL = new(ArgumentMatchers::AnyArgsMatcher::INSTANCE)
     end
   end
 end

data/rspec-mocks/upstream/lib/rspec/mocks/argument_matchers.rb

@@ -14,38 +14,38 @@ module RSpec
     #
     # @see ArgumentListMatcher
     module ArgumentMatchers
-      # Matches any args at all. Supports a more explicit variation of
-      # `expect(object).to receive(:message)`
+      # Acts like an arg splat, matching any number of args at any point in an arg list.
       #
       # @example
+      #   expect(object).to receive(:message).with(1, 2, any_args)
       #
-      #   expect(object).to receive(:message).with(any_args)
+      #   # matches any of these:
+      #   object.message(1, 2)
+      #   object.message(1, 2, 3)
+      #   object.message(1, 2, 3, 4)
       def any_args
-        AnyArgsMatcher.new
+        AnyArgsMatcher::INSTANCE
       end
 
       # Matches any argument at all.
       #
       # @example
-      #
       #   expect(object).to receive(:message).with(anything)
       def anything
-        AnyArgMatcher.new
+        AnyArgMatcher::INSTANCE
       end
 
       # Matches no arguments.
       #
       # @example
-      #
       #   expect(object).to receive(:message).with(no_args)
       def no_args
-        NoArgsMatcher.new
+        NoArgsMatcher::INSTANCE
       end
 
       # Matches if the actual argument responds to the specified messages.
       #
       # @example
-      #
       #   expect(object).to receive(:message).with(duck_type(:hello))
       #   expect(object).to receive(:message).with(duck_type(:hello, :goodbye))
       def duck_type(*args)
@@ -55,17 +55,15 @@ module RSpec
       # Matches a boolean value.
       #
       # @example
-      #
       #   expect(object).to receive(:message).with(boolean())
       def boolean
-        BooleanMatcher.new
+        BooleanMatcher::INSTANCE
       end
 
       # Matches a hash that includes the specified key(s) or key/value pairs.
       # Ignores any additional keys.
       #
       # @example
-      #
       #   expect(object).to receive(:message).with(hash_including(:key => val))
       #   expect(object).to receive(:message).with(hash_including(:key))
       #   expect(object).to receive(:message).with(hash_including(:key, :key2 => val2))
@@ -77,7 +75,6 @@ module RSpec
       # Ignores duplicates and additional values
       #
       # @example
-      #
       #   expect(object).to receive(:message).with(array_including(1,2,3))
       #   expect(object).to receive(:message).with(array_including([1,2,3]))
       def array_including(*args)
@@ -88,7 +85,6 @@ module RSpec
       # Matches a hash that doesn't include the specified key(s) or key/value.
       #
       # @example
-      #
       #   expect(object).to receive(:message).with(hash_excluding(:key => val))
       #   expect(object).to receive(:message).with(hash_excluding(:key))
       #   expect(object).to receive(:message).with(hash_excluding(:key, :key2 => :val2))
@@ -101,7 +97,6 @@ module RSpec
       # Matches if `arg.instance_of?(klass)`
       #
       # @example
-      #
       #   expect(object).to receive(:message).with(instance_of(Thing))
       def instance_of(klass)
         InstanceOf.new(klass)
@@ -110,8 +105,8 @@ module RSpec
       alias_method :an_instance_of, :instance_of
 
       # Matches if `arg.kind_of?(klass)`
-      # @example
       #
+      # @example
       #   expect(object).to receive(:message).with(kind_of(Thing))
       def kind_of(klass)
         KindOf.new(klass)
@@ -121,20 +116,37 @@ module RSpec
 
       # @private
       def self.anythingize_lonely_keys(*args)
-        hash = args.last.class == Hash ? args.delete_at(-1) : {}
-        args.each { | arg | hash[arg] = AnyArgMatcher.new }
+        hash = Hash === args.last ? args.delete_at(-1) : {}
+        args.each { | arg | hash[arg] = AnyArgMatcher::INSTANCE }
         hash
       end
 
+      # Intended to be subclassed by stateless, immutable argument matchers.
+      # Provides a `<klass name>::INSTANCE` constant for accessing a global
+      # singleton instance of the matcher. There is no need to construct
+      # multiple instance since there is no state. It also facilities the
+      # special case logic we need for some of these matchers, by making it
+      # easy to do comparisons like: `[klass::INSTANCE] == args` rather than
+      # `args.count == 1 && klass === args.first`.
+      #
+      # @private
+      class SingletonMatcher
+        private_class_method :new
+
+        def self.inherited(subklass)
+          subklass.const_set(:INSTANCE, subklass.send(:new))
+        end
+      end
+
       # @private
-      class AnyArgsMatcher
+      class AnyArgsMatcher < SingletonMatcher
         def description
-          "any args"
+          "*(any args)"
         end
       end
 
       # @private
-      class AnyArgMatcher
+      class AnyArgMatcher < SingletonMatcher
         def ===(_other)
           true
         end
@@ -145,14 +157,14 @@ module RSpec
       end
 
       # @private
-      class NoArgsMatcher
+      class NoArgsMatcher < SingletonMatcher
         def description
           "no args"
         end
       end
 
       # @private
-      class BooleanMatcher
+      class BooleanMatcher < SingletonMatcher
         def ===(value)
           true == value || false == value
         end
@@ -177,7 +189,20 @@ module RSpec
         end
 
         def description(name)
-          "#{name}(#{@expected.inspect.sub(/^\{/, "").sub(/\}$/, "")})"
+          "#{name}(#{formatted_expected_hash.inspect.sub(/^\{/, "").sub(/\}$/, "")})"
+        end
+
+      private
+
+        def formatted_expected_hash
+          Hash[
+            @expected.map do |k, v|
+              k = RSpec::Support.rspec_description_for_object(k)
+              v = RSpec::Support.rspec_description_for_object(v)
+
+              [k, v]
+            end
+          ]
         end
       end
 
@@ -210,11 +235,26 @@ module RSpec
         end
 
         def ===(actual)
-          Set.new(actual).superset?(Set.new(@expected))
+          actual = actual.uniq
+          @expected.uniq.all? do |expected_element|
+            actual.any? do |actual_element|
+              RSpec::Support::FuzzyMatcher.values_match?(expected_element, actual_element)
+            end
+          end
+        rescue NoMethodError
+          false
         end
 
         def description
-          "array_including(#{@expected.join(", ")})"
+          "array_including(#{formatted_expected_values})"
+        end
+
+      private
+
+        def formatted_expected_values
+          @expected.map do |x|
+            RSpec::Support.rspec_description_for_object(x)
+          end.join(", ")
         end
       end