opal-rspec 0.8.0.alpha3 → 1.0.0.alpha1

data/rspec-mocks/upstream/ISSUE_TEMPLATE.md

@@ -0,0 +1,24 @@
+### Subject of the issue
+<!---
+Describe your issue here.
+-->
+
+### Your environment
+* Ruby version:
+* rspec-mocks version:
+
+### Steps to reproduce
+<!---
+Tell us how to reproduce this issue. Please provide a working demo, you can use
+this [templates](REPORT_TEMPLATE.md) as a base.
+-->
+
+### Expected behavior
+<!---
+Tell us what should happen.
+-->
+
+### Actual behavior
+<!---
+Tell us what happens instead.
+-->

data/{rspec-expectations/upstream/License.txt → rspec-mocks/upstream/LICENSE.md}

@@ -1,8 +1,9 @@
-(The MIT License)
+The MIT License (MIT)
+=====================
 
-Copyright (c) 2012 David Chelimsky, Myron Marston
-Copyright (c) 2006 David Chelimsky, The RSpec Development Team
-Copyright (c) 2005 Steven Baker
+* Copyright © 2012 David Chelimsky, Myron Marston
+* Copyright © 2006 David Chelimsky, The RSpec Development Team
+* Copyright © 2005 Steven Baker
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/rspec-mocks/upstream/README.md

@@ -1,4 +1,4 @@
-# RSpec Mocks [![Build Status](https://secure.travis-ci.org/rspec/rspec-mocks.png?branch=master)](http://travis-ci.org/rspec/rspec-mocks) [![Code Climate](https://codeclimate.com/github/rspec/rspec-mocks.png)](https://codeclimate.com/github/rspec/rspec-mocks)
+# RSpec Mocks [![Build Status](https://github.com/rspec/rspec-mocks/workflows/RSpec%20CI/badge.svg)](https://github.com/rspec/rspec-mocks/actions) [![Code Climate](https://codeclimate.com/github/rspec/rspec-mocks.svg)](https://codeclimate.com/github/rspec/rspec-mocks)
 rspec-mocks is a test-double framework for rspec with support for method stubs,
 fakes, and message expectations on generated test-doubles and real objects
 alike.
@@ -8,6 +8,29 @@ alike.
     gem install rspec       # for rspec-core, rspec-expectations, rspec-mocks
     gem install rspec-mocks # for rspec-mocks only
 
+Want to run against the `main` branch? You'll need to include the dependent
+RSpec repos as well. Add the following to your `Gemfile`:
+
+```ruby
+%w[rspec-core rspec-expectations rspec-mocks rspec-support].each do |lib|
+  gem lib, :git => "https://github.com/rspec/#{lib}.git", :branch => 'main'
+end
+```
+## Contributing
+
+Once you've set up the environment, you'll need to cd into the working
+directory of whichever repo you want to work in. From there you can run the
+specs and cucumber features, and make patches.
+
+NOTE: You do not need to use rspec-dev to work on a specific RSpec repo. You
+can treat each RSpec repo as an independent project.
+
+For information about contributing to RSpec, please refer to the following markdown files:
+* [Build details](BUILD_DETAIL.md)
+* [Code of Conduct](CODE_OF_CONDUCT.md)
+* [Detailed contributing guide](CONTRIBUTING.md)
+* [Development setup guide](DEVELOPMENT.md)
+
 ## Test Doubles
 
 A test double is an object that stands in for another object in your system
@@ -30,7 +53,17 @@ book = instance_double("Book", :pages => 250)
 Verifying doubles have some clever tricks to enable you to both test in
 isolation without your dependencies loaded while still being able to validate
 them against real objects. More detail is available in [their
-documentation](https://github.com/rspec/rspec-mocks/blob/master/features/verifying_doubles).
+documentation](https://github.com/rspec/rspec-mocks/blob/main/features/verifying_doubles).
+
+Verifying doubles can also accept custom identifiers, just like double(), e.g.:
+
+```ruby
+books = []
+books << instance_double("Book", :rspec_book, :pages => 250)
+books << instance_double("Book", "(Untitled)", :pages => 5000)
+
+puts books.inspect # with names, it's clearer which were actually added
+```
 
 ## Method Stubs
 
@@ -42,7 +75,7 @@ rspec-mocks supports 3 forms for declaring method stubs:
 allow(book).to receive(:title) { "The RSpec Book" }
 allow(book).to receive(:title).and_return("The RSpec Book")
 allow(book).to receive_messages(
-    :title => "The RSpec Book", 
+    :title => "The RSpec Book",
     :subtitle => "Behaviour-Driven Development with RSpec, Cucumber, and Friends")
 ```
 
@@ -68,6 +101,21 @@ that iterates through them:
 order.calculate_total_price(double(:price => 1.99), double(:price => 2.99))
 ```
 
+### Stubbing a chain of methods
+
+You can use `receive_message_chain` in place of `receive` to stub a chain of messages:
+
+```ruby
+allow(double).to receive_message_chain("foo.bar") { :baz }
+allow(double).to receive_message_chain(:foo, :bar => :baz)
+allow(double).to receive_message_chain(:foo, :bar) { :baz }
+
+# Given any of the above forms:
+double.foo.bar # => :baz
+```
+
+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 `receive_message_chain` a code smell. Even though not all code smells indicate real problems (think fluent interfaces), `receive_message_chain` still results in brittle examples. For example, if you write `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.
+
 ## Consecutive return values
 
 When a stub might be invoked more than once, you can provide additional
@@ -117,8 +165,7 @@ class_spy("Invitation") # => same as `class_double("Invitation").as_null_object`
 object_spy("Invitation") # => same as `object_double("Invitation").as_null_object`
 ```
 
-Stubbing and verifying messages received in this way implements the Test Spy
-pattern.
+Verifying messages received in this way implements the Test Spy pattern.
 
 ```ruby
 invitation = spy('invitation')
@@ -138,6 +185,20 @@ expect(invitation).to have_received(:accept).with(mailer)
 expect(invitation.accept).to eq(true)
 ```
 
+Note that `have_received(...).with(...)` is unable to work properly when
+passed arguments are mutated after the spy records the received message.
+For example, this does not work properly:
+
+```ruby
+greeter = spy("greeter")
+
+message = "Hello"
+greeter.greet_with(message)
+message << ", World"
+
+expect(greeter).to have_received(:greet_with).with("Hello")
+```
+
 ## Nomenclature
 
 ### Mock Objects and Test Stubs
@@ -196,7 +257,7 @@ expect(double).to receive(:msg).with("B", 2, 4)
 ## Argument Matchers
 
 Arguments that are passed to `with` are compared with actual arguments
-received using ==. In cases in which you want to specify things about the
+received using ===. In cases in which you want to specify things about the
 arguments rather than the arguments themselves, you can use any of the
 matchers that ship with rspec-expectations. They don't all make syntactic
 sense (they were primarily designed for use with RSpec::Expectations), but
@@ -206,8 +267,9 @@ rspec-mocks also adds some keyword Symbols that you can use to
 specify certain kinds of arguments:
 
 ```ruby
-expect(double).to receive(:msg).with(no_args())
-expect(double).to receive(:msg).with(any_args())
+expect(double).to receive(:msg).with(no_args)
+expect(double).to receive(:msg).with(any_args)
+expect(double).to receive(:msg).with(1, any_args) # any args acts like an arg splat and can go anywhere
 expect(double).to receive(:msg).with(1, kind_of(Numeric), "b") #2nd argument can be any kind of Numeric
 expect(double).to receive(:msg).with(1, boolean(), "b") #2nd argument can be true or false
 expect(double).to receive(:msg).with(1, /abc/, "b") #2nd argument can be any String matching the submitted Regexp
@@ -223,12 +285,15 @@ expect(double).to receive(:msg).with(hash_excluding(:a => 5)) # first arg is a h
 ```ruby
 expect(double).to receive(:msg).once
 expect(double).to receive(:msg).twice
+expect(double).to receive(:msg).exactly(n).time
 expect(double).to receive(:msg).exactly(n).times
 expect(double).to receive(:msg).at_least(:once)
 expect(double).to receive(:msg).at_least(:twice)
+expect(double).to receive(:msg).at_least(n).time
 expect(double).to receive(:msg).at_least(n).times
 expect(double).to receive(:msg).at_most(:once)
 expect(double).to receive(:msg).at_most(:twice)
+expect(double).to receive(:msg).at_most(n).time
 expect(double).to receive(:msg).at_most(n).times
 ```
 
@@ -265,7 +330,7 @@ expect(double).to receive(:msg).and_return(value)
 expect(double).to receive(:msg).exactly(3).times.and_return(value1, value2, value3)
   # returns value1 the first time, value2 the second, etc
 expect(double).to receive(:msg).and_raise(error)
-  # error can be an instantiated object or a class
+  # `error` can be an instantiated object (e.g. `StandardError.new(some_arg)`) or a class (e.g. `StandardError`)
   # if it is a class, it must be instantiable with no args
 expect(double).to receive(:msg).and_throw(:msg)
 expect(double).to receive(:msg).and_yield(values, to, yield)
@@ -313,7 +378,7 @@ end
 ## Delegating to the Original Implementation
 
 When working with a partial mock object, you may occasionally
-want to set a message expecation without interfering with how
+want to set a message expectation without interfering with how
 the object responds to the message. You can use `and_call_original`
 to achieve this:
 
@@ -338,7 +403,7 @@ your code.
 ## Stubbing and Hiding Constants
 
 See the [mutating constants
-README](https://github.com/rspec/rspec-mocks/blob/master/features/mutating_constants/README.md)
+README](https://github.com/rspec/rspec-mocks/blob/main/features/mutating_constants/README.md)
 for info on this feature.
 
 ## Use `before(:example)`, not `before(:context)`
@@ -366,7 +431,7 @@ general we 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 edge cases. For example in
+  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, or if two
   receives total are expected. (It's the former.)
@@ -384,14 +449,15 @@ There are many different viewpoints about the meaning of mocks and stubs. If
 you are interested in learning more, here is some recommended reading:
 
 * Mock Objects: http://www.mockobjects.com/
-* Endo-Testing: http://stalatest.googlecode.com/svn/trunk/Literatur/mockobjects.pdf
-* Mock Roles, Not Objects: http://jmock.org/oopsla2004.pdf
+* Endo-Testing: http://www.ccs.neu.edu/research/demeter/related-work/extreme-programming/MockObjectsFinal.PDF
+* Mock Roles, Not Objects: http://www.jmock.org/oopsla2004.pdf
 * Test Double: http://www.martinfowler.com/bliki/TestDouble.html
 * Test Double Patterns: http://xunitpatterns.com/Test%20Double%20Patterns.html
 * Mocks aren't stubs: http://www.martinfowler.com/articles/mocksArentStubs.html
 
 ## Also see
 
-* [http://github.com/rspec/rspec](http://github.com/rspec/rspec)
-* [http://github.com/rspec/rspec-core](http://github.com/rspec/rspec-core)
-* [http://github.com/rspec/rspec-expectations](http://github.com/rspec/rspec-expectations)
+* [https://github.com/rspec/rspec](https://github.com/rspec/rspec)
+* [https://github.com/rspec/rspec-core](https://github.com/rspec/rspec-core)
+* [https://github.com/rspec/rspec-expectations](https://github.com/rspec/rspec-expectations)
+* [https://github.com/rspec/rspec-rails](https://github.com/rspec/rspec-rails)

data/rspec-mocks/upstream/REPORT_TEMPLATE.md

@@ -0,0 +1,43 @@
+<!---
+This file was generated on 2020-12-25T18:48:30+00:00 from the rspec-dev repo.
+DO NOT modify it by hand as your changes will get lost the next time it is generated.
+-->
+
+# Report template
+
+```ruby
+# frozen_string_literal: true
+
+begin
+  require "bundler/inline"
+rescue LoadError => e
+  $stderr.puts "Bundler version 1.10 or later is required. Please update your Bundler"
+  raise e
+end
+
+gemfile(true) do
+  source "https://rubygems.org"
+
+  gem "rspec", "3.7.0" # Activate the gem and version you are reporting the issue against.
+end
+
+puts "Ruby version is: #{RUBY_VERSION}"
+require 'rspec/autorun'
+
+RSpec.describe 'additions' do
+  it 'returns 2' do
+    expect(1 + 1).to eq(2)
+  end
+
+  it 'returns 1' do
+    expect(3 - 1).to eq(-1)
+  end
+end
+```
+
+Simply copy the content of the appropriate template into a `.rb` file on your computer
+and make the necessary changes to demonstrate the issue. You can execute it by running
+`ruby rspec_report.rb` in your terminal.
+
+You can then share your executable test case as a [gist](https://gist.github.com), or
+simply paste the content into the issue description.

data/rspec-mocks/upstream/Rakefile

@@ -26,7 +26,7 @@ end
 namespace :clobber do
   desc "remove generated rbc files"
   task :rbc do
-    Dir['**/*.rbc'].each {|f| File.delete(f)}
+    Dir['**/*.rbc'].each { |f| File.delete(f) }
   end
 end
 
@@ -40,7 +40,7 @@ with_changelog_in_features = lambda do |&block|
 end
 
 desc "Push docs/cukes to relishapp using the relish-client-gem"
-task :relish, :version do |t, args|
+task :relish, :version do |_t, args|
   raise "rake relish[VERSION]" unless args[:version]
 
   with_changelog_in_features.call do
@@ -65,7 +65,7 @@ task :default => [:spec, :cucumber]
 task :verify_private_key_present do
   private_key = File.expand_path('~/.gem/rspec-gem-private_key.pem')
   unless File.exist?(private_key)
-    raise "Your private key is not present. This gem should not be built without that."
+    raise "Your private key is not present. This gem should not be built without it."
   end
 end
 

data/rspec-mocks/upstream/benchmarks/accessing_configuration_via_method_vs_cache.rb

@@ -0,0 +1,52 @@
+require 'benchmark'
+
+n = 10_000
+
+require 'rspec/mocks'
+
+# precache config
+RSpec::Mocks.configuration
+
+Benchmark.benchmark do |bm|
+  puts "#{n} times - ruby #{RUBY_VERSION}"
+
+  puts
+  puts "directly"
+
+  3.times do
+    bm.report do
+      n.times do
+        original_state = RSpec::Mocks.configuration.temporarily_suppress_partial_double_verification
+        RSpec::Mocks.configuration.temporarily_suppress_partial_double_verification = true
+        RSpec::Mocks.configuration.temporarily_suppress_partial_double_verification = original_state
+      end
+    end
+  end
+
+  puts
+  puts "with cached value"
+
+  3.times do
+    bm.report do
+      n.times do
+        config = RSpec::Mocks.configuration
+        original_state = config.temporarily_suppress_partial_double_verification
+        config.temporarily_suppress_partial_double_verification = true
+        config.temporarily_suppress_partial_double_verification = original_state
+      end
+    end
+  end
+end
+
+__END__
+10000 times - ruby 2.3.1
+
+directly
+   0.000000   0.000000   0.000000 (  0.002654)
+   0.000000   0.000000   0.000000 (  0.002647)
+   0.010000   0.000000   0.010000 (  0.002645)
+
+with cached value
+   0.000000   0.000000   0.000000 (  0.001386)
+   0.000000   0.000000   0.000000 (  0.001387)
+   0.000000   0.000000   0.000000 (  0.001399)

data/rspec-mocks/upstream/benchmarks/allocations/1_object_1000_mocks.rb

@@ -0,0 +1,76 @@
+require_relative "helper"
+symbols = (1..1000).map { |x| :"#{x}" }
+
+benchmark_allocations do
+  o = Object.new
+  symbols.each do |sym|
+    expect(o).to receive(sym)
+  end
+
+  symbols.each do |sym|
+    o.send(sym)
+  end
+
+  RSpec::Mocks.space.verify_all
+  RSpec::Mocks.space.reset_all
+end
+
+__END__
+As of commit 9ee3e3adb529113bf1cc75cc4424d014f880dc47:
+
+                     class_plus                       count
+----------------------------------------------------  -----
+Array                                                 22003
+Proc                                                   3001
+RubyVM::Env                                            3001
+Array<Symbol>                                          2000
+String                                                 2000
+Hash                                                   1002
+RSpec::Mocks::ExpectationTarget                        1000
+Enumerator                                             1000
+RSpec::Mocks::Matchers::Receive                        1000
+Array<Fixnum>                                          1000
+RSpec::Mocks::InstanceMethodStasher                    1000
+RSpec::Mocks::MethodDouble                             1000
+Array<NilClass>                                        1000
+RSpec::Mocks::MessageExpectation                       1000
+Array<RSpec::Mocks::MethodDouble,Symbol>               1000
+Array<Array>                                           1000
+Array<RSpec::Mocks::ArgumentMatchers::NoArgsMatcher>   1000
+Array<Symbol,Array,NilClass>                           1000
+RSpec::Mocks::Proxy::SpecificMessage                   1000
+RSpec::Mocks::Implementation                           1000
+Array<Class,Module>                                       1
+RSpec::Mocks::PartialDoubleProxy                          1
+RSpec::Mocks::ErrorGenerator                              1
+Array<RSpec::Mocks::PartialDoubleProxy>                   1
+
+
+After PR #936:
+
+                     class_plus                       count
+----------------------------------------------------  -----
+Array                                                 21003
+RubyVM::Env                                            3001
+Proc                                                   3001
+String                                                 2000
+RSpec::Mocks::InstanceMethodStasher                    1000
+RSpec::Mocks::Matchers::Receive                        1000
+RSpec::Mocks::ExpectationTarget                        1000
+RSpec::Mocks::Implementation                           1000
+RSpec::Mocks::MessageExpectation                       1000
+RSpec::Mocks::MethodDouble                             1000
+Array<Symbol>                                          1000
+Array<RSpec::Mocks::MethodDouble,Symbol>               1000
+Array<Array>                                           1000
+Enumerator                                             1000
+Array<RSpec::Mocks::ArgumentMatchers::NoArgsMatcher>   1000
+Array<Symbol,Array,NilClass>                           1000
+RSpec::Mocks::Proxy::SpecificMessage                   1000
+Array<NilClass>                                        1000
+Array<Fixnum>                                          1000
+Hash                                                      2
+RSpec::Mocks::PartialDoubleProxy                          1
+Array<RSpec::Mocks::PartialDoubleProxy>                   1
+RSpec::Mocks::ErrorGenerator                              1
+Array<Class,Module>                                       1

data/rspec-mocks/upstream/benchmarks/allocations/helper.rb

@@ -0,0 +1,17 @@
+$LOAD_PATH.unshift File.expand_path("../../../lib", __FILE__)
+require "allocation_stats"
+require 'rspec/mocks/standalone'
+
+def benchmark_allocations(burn: 1)
+  stats = AllocationStats.new(:burn => burn).trace do
+    yield
+  end
+
+  columns = if ENV['DETAIL']
+              [:sourcefile, :sourceline, :class_plus]
+            else
+              [:class_plus]
+            end
+
+  puts stats.allocations(:alias_paths => true).group_by(*columns).from_pwd.sort_by_size.to_text
+end

data/rspec-mocks/upstream/benchmarks/each_value_v_values_each.rb

@@ -1,8 +1,8 @@
 require 'benchmark'
 
-n = 10000
+n = 10_000
 
-m = 1.upto(1000).reduce({}) {|m, i| m[i] = i; m}
+m = 1.upto(1000).inject({}) { |m, i| m[i] = i; m }
 
 Benchmark.benchmark do |bm|
   puts "#{n} times - ruby #{RUBY_VERSION}"
@@ -13,7 +13,7 @@ Benchmark.benchmark do |bm|
   3.times do
     bm.report do
       n.times do
-        m.each_value {|v|}
+        m.each_value {}
       end
     end
   end
@@ -24,7 +24,7 @@ Benchmark.benchmark do |bm|
   3.times do
     bm.report do
       n.times do
-        m.values.each{|v|}
+        m.values.each {}
       end
     end
   end
@@ -43,7 +43,6 @@ end
 #    0.910000   0.010000   0.920000 (  0.909319)
 #    0.910000   0.000000   0.910000 (  0.911225)
 
-
 # $ ruby benchmarks/values_each_v_each_value.rb
 # 10000 times - ruby 2.0.0
 #

data/rspec-mocks/upstream/benchmarks/find_original_method_early.rb

@@ -14,7 +14,7 @@ with the original method being found vs. not.
 
 require 'benchmark'
 
-n = 10000
+n = 10_000
 
 Foo = Class.new(Object) do
   n.times do |i|

data/rspec-mocks/upstream/benchmarks/method_defined_at_any_visibility.rb

@@ -4,10 +4,10 @@ n = 1_000_000
 
 Foo = Class.new do
   1.upto(n) do |i|
-    define_method(:"public_method_#{i}") { }
-    define_method(:"protected_method_#{i}") { }
+    define_method(:"public_method_#{i}") {}
+    define_method(:"protected_method_#{i}") {}
     protected :"protected_method_#{i}"
-    define_method(:"private_method_#{i}") { }
+    define_method(:"private_method_#{i}") {}
     private :"protected_method_#{i}"
   end
 end

data/rspec-mocks/upstream/benchmarks/thread_safety.rb

@@ -7,7 +7,7 @@ Benchmark.bm do |bm|
   bm.report("fetching a proxy") do
     RSpec::Mocks.with_temporary_scope do
       o = Object.new
-      100000.times {
+      100_000.times {
         RSpec::Mocks.space.proxy_for(o)
       }
     end

data/rspec-mocks/upstream/benchmarks/transfer_nested_constants.rb

@@ -3,7 +3,7 @@ $LOAD_PATH.unshift(File.expand_path("../../lib", __FILE__))
 require 'benchmark'
 require 'rspec/mocks'
 
-N = ENV.fetch('N', 10000).to_i
+N = ENV.fetch('N', 10_000).to_i
 M = ENV.fetch('M', 5).to_i
 
 puts "#{N} times, #{M} constants - ruby #{RUBY_VERSION}"

data/rspec-mocks/upstream/cucumber.yml

@@ -1,2 +1,9 @@
-default: --require features --tags ~@wip features --format progress
+<%
+
+USE_TILDE_TAGS = !defined?(::RUBY_ENGINE_VERSION) || (::RUBY_ENGINE_VERSION < '2.0.0')
+NOT_WIP_TAG = USE_TILDE_TAGS ? '~@wip' : '"not @wip"'
+
+%>
+
+default: --require features --tags <%= NOT_WIP_TAG %> features --format progress
 wip: --require features --tags @wip:3 --wip features

data/rspec-mocks/upstream/features/.nav

@@ -18,6 +18,7 @@
   - throwing.feature
   - yielding.feature
   - calling_the_original_implementation.feature
+  - wrapping_the_original_implementation.feature
   - block_implementation.feature
 - setting_constraints:
   - matching_arguments.feature
@@ -39,5 +40,6 @@
   - unstub.feature
 - outside_rspec:
   - minitest.feature
+  - any_test_framework.feature
   - standalone.feature
 - Changelog

data/rspec-mocks/upstream/features/basics/allowing_messages.feature

@@ -2,7 +2,7 @@ Feature: Allowing messages
 
   [Test doubles](./test-doubles) are "strict" by default -- messages that have not been specifically
   allowed or expected will trigger an error. Use `allow(...).to receive(...)` to configure
-  which messages are the double is allowed to receive. You can also use `allow(...).to
+  which messages the double is allowed to receive. You can also use `allow(...).to
   receive_messages(...)` to configure allowed messages (and return values) in bulk.
 
   Scenario: Allowed messages return nil by default

data/rspec-mocks/upstream/features/basics/expecting_messages.feature

@@ -19,7 +19,8 @@ Feature: Expecting messages
       """
         1) An unfulfilled positive message expectation triggers a failure
            Failure/Error: expect(dbl).to receive(:foo)
-             (Double "Some Collaborator").foo(any args)
+
+             (Double "Some Collaborator").foo(*(any args))
                  expected: 1 time with any arguments
                  received: 0 times with any arguments
       """
@@ -54,6 +55,7 @@ Feature: Expecting messages
       """
         1) A negative message expectation fails when the message is received
            Failure/Error: dbl.foo
+
              (Double "Some Collaborator").foo(no args)
                  expected: 0 times with any arguments
                  received: 1 time
@@ -71,3 +73,40 @@ Feature: Expecting messages
       """
      When I run `rspec negative_message_expectation_spec.rb`
      Then the examples should all pass
+
+  Scenario: Failing positive message expectation with a custom failure message
+    Given a file named "example_spec.rb" with:
+    """ruby
+    RSpec.describe "An unfulfilled positive message expectation" do
+      it "triggers a failure" do
+        dbl = double
+        expect(dbl).to receive(:foo), "dbl never calls :foo"
+      end
+    end
+    """
+    When I run `rspec example_spec.rb --format documentation`
+    Then the output should contain:
+    """
+      1) An unfulfilled positive message expectation triggers a failure
+         Failure/Error: expect(dbl).to receive(:foo), "dbl never calls :foo"
+           dbl never calls :foo
+    """
+
+  Scenario: Failing negative message expectation with a custom failure message
+    Given a file named "example_spec.rb" with:
+    """ruby
+    RSpec.describe "A negative message expectation" do
+      it "fails when the message is received" do
+        dbl = double
+        expect(dbl).not_to receive(:foo), "dbl called :foo but is not supposed to"
+        dbl.foo
+      end
+    end
+    """
+    When I run `rspec example_spec.rb --format documentation`
+    Then the output should contain:
+    """
+      1) A negative message expectation fails when the message is received
+         Failure/Error: dbl.foo
+           dbl called :foo but is not supposed to
+    """

data/rspec-mocks/upstream/features/basics/null_object_doubles.feature

@@ -3,7 +3,7 @@ Feature: Null object doubles
   [Test doubles](./test-doubles) are strict by default, raising errors when they receive messages that have not
   been allowed or expected. You can chain `as_null_object` off of `double` in order to make
   the double "loose". For any message that has not explicitly allowed or expected, the double
-  will return itself. It acts as a block-hole null object, allowing arbitrarily deep method chains.
+  will return itself. It acts as a black hole null object, allowing arbitrarily deep method chains.
 
   Scenario: `as_null_object` allows arbitrarily deep message chains and returns itself
     Given a file named "as_null_object_spec.rb" with:

data/rspec-mocks/upstream/features/basics/partial_test_doubles.feature

@@ -19,7 +19,7 @@ Feature: Partial test doubles
   expect(Person).to receive(:find) { person }
   ```
 
-  RSpec replaces the method we're stubbing or mocking with its own test-double-like method.
+  RSpec replaces the method we're stubbing or mocking with its own test-double like method.
   At the end of the example, RSpec verifies any message expectations, and then restores the
   original methods.