opal-rspec 0.8.0 → 1.0.0

data/rspec-mocks/upstream/features/outside_rspec/minitest.feature

@@ -1,80 +1,236 @@
 Feature: Integrate with Minitest
 
-  rspec-mocks is a stand-alone gem that can be integrated with any test framework. The
-  example below demonstrates using rspec-mocks with [minitest](http://docs.seattlerb.org/minitest/), but these steps
-  would apply when integrating rspec-mocks with any library or framework:
-
-    * Include `RSpec::Mocks::ExampleMethods` in your test context. This provides rspec-mocks' API.
-    * Call `RSpec::Mocks.setup` before a test begins.
-    * Call `RSpec::Mocks.verify` after a test completes to verify message expectations. Note
-      that this step is optional; rspec-core, for example, skips this when an example has already failed.
-    * Call `RSpec::Mocks.teardown` after a test completes (and after `verify`) to cleanup. This
-      _must_ be called, even if an error has occurred, so it generally goes in an `ensure` clause.
-
-  Scenario: Use rspec-mocks with Minitest
-    Given a file named "test/test_helper.rb" with:
+  To use rspec-mocks with minitest, simply require `rspec/mocks/minitest_integration`.
+
+  Scenario: Use rspec-mocks with Minitest::Test
+    Given a file named "test/rspec_mocks_test.rb" with:
       """ruby
       require 'minitest/autorun'
-      require 'rspec/mocks'
+      require 'rspec/mocks/minitest_integration'
+
+      class RSpecMocksTest < Minitest::Test
+        def test_passing_positive_expectation
+          dbl = double
+          expect(dbl).to receive(:message)
+          dbl.message
+        end
+
+        def test_failing_positive_expectation
+          dbl = double
+          expect(dbl).to receive(:message)
+        end
+
+        def test_passing_negative_expectation
+          dbl = double
+          expect(dbl).to_not receive(:message)
+        end
+
+        def test_failing_negative_expectation
+          dbl = double
+          expect(dbl).to_not receive(:message)
+          dbl.message
+        end
 
-      module MinitestRSpecMocksIntegration
-        include ::RSpec::Mocks::ExampleMethods
+        def test_passing_positive_spy_expectation
+          bond = spy
+          bond.james
+          expect(bond).to have_received(:james)
+        end
+
+        def test_failing_positive_spy_expectation
+          bond = spy
+          expect(bond).to have_received(:james)
+        end
 
-        def before_setup
-          ::RSpec::Mocks.setup
-          super
+        def test_passing_negative_spy_expectation
+          bond = spy
+          expect(bond).not_to have_received(:james)
         end
 
-        def after_teardown
-          super
-          ::RSpec::Mocks.verify
-        ensure
-          ::RSpec::Mocks.teardown
+        def test_failing_negative_spy_expectation
+          bond = spy
+          bond.james
+          expect(bond).not_to have_received(:james)
         end
       end
+      """
+     When I run `ruby test/rspec_mocks_test.rb --seed 0`
+     Then it should fail with the following output:
+       |   1) Failure:                                        |
+       | RSpecMocksTest#test_failing_positive_expectation     |
+       | (Double (anonymous)).message(*(any args))            |
+       |     expected: 1 time with any arguments              |
+       |     received: 0 times with any arguments             |
+       |                                                      |
+       |   2) Failure:                                        |
+       | RSpecMocksTest#test_failing_negative_expectation     |
+       | (Double (anonymous)).message(no args)                |
+       |     expected: 0 times with any arguments             |
+       |     received: 1 time                                 |
+       |                                                      |
+       |   3) Failure:                                        |
+       | RSpecMocksTest#test_failing_positive_spy_expectation |
+       | (Double (anonymous)).james(*(any args))              |
+       |     expected: 1 time with any arguments              |
+       |     received: 0 times with any arguments             |
+       |                                                      |
+       |   4) Failure:                                        |
+       | RSpecMocksTest#test_failing_negative_spy_expectation |
+       | (Double (anonymous)).james(no args)                  |
+       |     expected: 0 times with any arguments             |
+       |     received: 1 time                                 |
+       |                                                      |
+       |  8 runs, 0 assertions, 4 failures, 0 errors, 0 skips |
+
+  Scenario: Use rspec-mocks with Minitest::Spec
+    Given a file named "spec/rspec_mocks_spec.rb" with:
+      """ruby
+      require 'minitest/autorun'
+      require 'minitest/spec'
+      require 'rspec/mocks/minitest_integration'
 
-      Minitest::Test.send(:include, MinitestRSpecMocksIntegration)
+      describe "Minitest Spec integration" do
+        it 'passes a positive expectation' do
+          dbl = double
+          expect(dbl).to receive(:message)
+          dbl.message
+        end
+
+        it 'fails a positive expectation' do
+          dbl = double
+          expect(dbl).to receive(:message)
+        end
+
+        it 'passes a negative expectation (using to_not)' do
+          dbl = double
+          expect(dbl).to_not receive(:message)
+        end
+
+        it 'fails a negative expectation (using not_to)' do
+          dbl = double
+          expect(dbl).not_to receive(:message)
+          dbl.message
+        end
+      end
       """
-    And a file named "test/rspec_mocks_test.rb" with:
+     When I run `ruby spec/rspec_mocks_spec.rb --seed 0`
+     Then it should fail with the following output:
+       |   1) Failure:                                                                   |
+       | Minitest Spec integration#test_0002_fails a positive expectation                |
+       | (Double (anonymous)).message(*(any args))                                       |
+       |     expected: 1 time with any arguments                                         |
+       |     received: 0 times with any arguments                                        |
+       |                                                                                 |
+       |   2) Failure:                                                                   |
+       | Minitest Spec integration#test_0004_fails a negative expectation (using not_to) |
+       | (Double (anonymous)).message(no args)                                           |
+       |     expected: 0 times with any arguments                                        |
+       |     received: 1 time                                                            |
+       |                                                                                 |
+       |  4 runs, 4 assertions, 2 failures, 0 errors, 0 skips                            |
+
+  Scenario: Load rspec-mocks before rspec-expectations, with Minitest::Spec
+    Given a file named "spec/rspec_mocks_spec.rb" with:
       """ruby
-      require 'test_helper'
+      require 'minitest/autorun'
+      require 'minitest/spec'
+      require 'rspec/mocks/minitest_integration'
+      require 'rspec/expectations/minitest_integration'
 
-      class RSpecMocksTest < Minitest::Test
-        def test_passing_positive_expectation
+      describe "Minitest Spec integration" do
+        it 'passes a positive expectation' do
           dbl = double
           expect(dbl).to receive(:message)
           dbl.message
         end
 
-        def test_failing_positive_expectation
+        it 'fails a positive expectation' do
           dbl = double
           expect(dbl).to receive(:message)
         end
 
-        def test_passing_negative_expectation
+        it 'passes a negative expectation (using to_not)' do
           dbl = double
           expect(dbl).to_not receive(:message)
         end
 
-        def test_failing_negative_expectation
+        it 'fails a negative expectation (using not_to)' do
+          dbl = double
+          expect(dbl).not_to receive(:message)
+          dbl.message
+        end
+
+        it 'can use both minitest and rspec expectations' do
+          expect(1 + 3).must_equal 4
+          expect(1 + 3).to eq 4
+        end
+      end
+      """
+     When I run `ruby spec/rspec_mocks_spec.rb --seed 0`
+     Then it should fail with the following output:
+       |   1) Failure:                                                                   |
+       | Minitest Spec integration#test_0002_fails a positive expectation                |
+       | (Double (anonymous)).message(*(any args))                                       |
+       |     expected: 1 time with any arguments                                         |
+       |     received: 0 times with any arguments                                        |
+       |                                                                                 |
+       |   2) Failure:                                                                   |
+       | Minitest Spec integration#test_0004_fails a negative expectation (using not_to) |
+       | (Double (anonymous)).message(no args)                                           |
+       |     expected: 0 times with any arguments                                        |
+       |     received: 1 time                                                            |
+       |                                                                                 |
+       |  5 runs, 6 assertions, 2 failures, 0 errors, 0 skips                            |
+
+  Scenario: Load rspec-mocks after rspec-expectations, with Minitest::Spec
+    Given a file named "spec/rspec_mocks_spec.rb" with:
+      """ruby
+      require 'minitest/autorun'
+      require 'minitest/spec'
+      require 'rspec/expectations/minitest_integration'
+      require 'rspec/mocks/minitest_integration'
+
+      describe "Minitest Spec integration" do
+        it 'passes a positive expectation' do
+          dbl = double
+          expect(dbl).to receive(:message)
+          dbl.message
+        end
+
+        it 'fails a positive expectation' do
+          dbl = double
+          expect(dbl).to receive(:message)
+        end
+
+        it 'passes a negative expectation (using to_not)' do
           dbl = double
           expect(dbl).to_not receive(:message)
+        end
+
+        it 'fails a negative expectation (using not_to)' do
+          dbl = double
+          expect(dbl).not_to receive(:message)
           dbl.message
         end
+
+        it 'can use both minitest and rspec expectations' do
+          expect(1 + 3).must_equal 4
+          expect(1 + 3).to eq 4
+        end
       end
       """
-     When I run `ruby -Itest test/rspec_mocks_test.rb`
+     When I run `ruby spec/rspec_mocks_spec.rb --seed 0`
      Then it should fail with the following output:
-       |   1) Error:                                                    |
-       | RSpecMocksTest#test_failing_negative_expectation:              |
-       | RSpec::Mocks::MockExpectationError: (Double).message(no args)  |
-       |     expected: 0 times with any arguments                       |
-       |     received: 1 time                                           |
-       |                                                                |
-       |   2) Error:                                                    |
-       | RSpecMocksTest#test_failing_positive_expectation:              |
-       | RSpec::Mocks::MockExpectationError: (Double).message(any args) |
-       |     expected: 1 time with any arguments                        |
-       |     received: 0 times with any arguments                       |
-       |                                                                |
-       |  4 runs, 0 assertions, 0 failures, 2 errors, 0 skips           |
+       |   1) Failure:                                                                   |
+       | Minitest Spec integration#test_0002_fails a positive expectation                |
+       | (Double (anonymous)).message(*(any args))                                       |
+       |     expected: 1 time with any arguments                                         |
+       |     received: 0 times with any arguments                                        |
+       |                                                                                 |
+       |   2) Failure:                                                                   |
+       | Minitest Spec integration#test_0004_fails a negative expectation (using not_to) |
+       | (Double (anonymous)).message(no args)                                           |
+       |     expected: 0 times with any arguments                                        |
+       |     received: 1 time                                                            |
+       |                                                                                 |
+       |  5 runs, 6 assertions, 2 failures, 0 errors, 0 skips                            |

data/rspec-mocks/upstream/features/outside_rspec/standalone.feature

@@ -1,7 +1,7 @@
 Feature: Standalone
 
   `require "rspec/mocks/standalone"` to expose the API at the top level (e.g. `main`) outside
-  the RSpec environment. This is especially useful for exploring rspec-mocks in irb.
+  the RSpec environment in a REPL like IRB or in a one-off script.
 
   Scenario: Allow a message outside RSpec
     Given a file named "example.rb" with:
@@ -27,7 +27,7 @@ Feature: Standalone
       """
     When I run `ruby example.rb`
     Then it should fail with the following output:
-      | (Double "greeter").say_hi(any args)  |
-      | RSpec::Mocks::MockExpectationError   |
-      | expected: 1 time with any arguments  |
-      | received: 0 times with any arguments |
+      | (Double "greeter").say_hi(*(any args)) |
+      | RSpec::Mocks::MockExpectationError     |
+      | expected: 1 time with any arguments    |
+      | received: 0 times with any arguments   |

data/rspec-mocks/upstream/features/setting_constraints/matching_arguments.feature

@@ -4,21 +4,23 @@ Feature: Matching arguments
   will only be satisfied when called with matching arguments. A canned response for an
   [allowed message](../basics/allowing-messages) will only be used when the arguments match.
 
-  | To match...                                         | ...use an expression like:      | ...which matches calls like:          |
-  | --------------------------------------------------- | ------------------------------- | ------------------------------------- |
-  | Literal arguments                                   | `with(1, true)`                 | `foo(1, true)`                        |
-  | Anything that supports case equality (`===`)        | `with(/bar/)`                   | `foo("barn")`                         |
-  | Any list of args                                    | `with(any_args)`                | `foo()`<br>`foo(1)`<br>`foo(:bar, 2)` |
-  | An empty list of args                               | `with(no_args)`                 | `foo()`                               |
-  | Anything for a given positional arg                 | `with(3, anything)`             | `foo(3, nil)`<br>`foo(3, :bar)`       |
-  | Against an interface                                | `with(duck_type(:each))`        | `foo([])`                             |
-  | A boolean                                           | `with(3, boolean)`              | `foo(3, true)`<br>`foo(3, false)`     |
-  | A subset of a hash                                  | `with(hash_including(:a => 1))` | `foo(:a => 1, :b => 2)`               |
-  | An excluded subset of a hash                        | `with(hash_excluding(:a => 1))` | `foo(:b => 2)`                        |
-  | A subset of an array                                | `with(array_including(:a, :b))` | `foo([:a, :b, :c])`                   |
-  | An instance of a specific class                     | `with(instance_of(Fixnum))`     | `foo(3)`                              |
-  | An object with a given module in its ancestors list | `with(kind_of(Numeric))`        | `foo(3)`                              |
-  | Any RSpec matcher                                   | `with(<matcher>)`               | `foo(<object that matches>)`          |
+  | To match...                                         | ...use an expression like:         | ...which matches calls like:          |
+  | --------------------------------------------------- | ---------------------------------  | ------------------------------------- |
+  | Literal arguments                                   | `with(1, true)`                    | `foo(1, true)`                        |
+  | Anything that supports case equality (`===`)        | `with(/bar/)`                      | `foo("barn")`                         |
+  | Any list of args                                    | `with(any_args)`                   | `foo()`<br>`foo(1)`<br>`foo(:bar, 2)` |
+  | Any sublist of args (like an arg splat)             | `with(1, any_args)`                | `foo(1)`<br>`foo(1, :bar, :bazz)`     |
+  | An empty list of args                               | `with(no_args)`                    | `foo()`                               |
+  | Anything for a given positional arg                 | `with(3, anything)`                | `foo(3, nil)`<br>`foo(3, :bar)`       |
+  | Against an interface                                | `with(duck_type(:each))`           | `foo([])`                             |
+  | A boolean                                           | `with(3, boolean)`                 | `foo(3, true)`<br>`foo(3, false)`     |
+  | A subset of a hash                                  | `with(hash_including(:a => 1))`    | `foo(:a => 1, :b => 2)`               |
+  | An excluded subset of a hash                        | `with(hash_excluding(:a => 1))`    | `foo(:b => 2)`                        |
+  | A subset of an array                                | `with(array_including(:a, :b))`    | `foo([:a, :b, :c])`                   |
+  | An instance of a specific class                     | `with(instance_of(Integer))`       |  `foo(3)`                             |
+  | An object with a given module in its ancestors list | `with(kind_of(Numeric))`           | `foo(3)`                              |
+  | An object with matching attributes                  | `with(having_attributes(:a => 1))` | `foo(:a => 1, :b => 2)`               |
+  | Any RSpec matcher                                   | `with(<matcher>)`                  | `foo(<object that matches>)`          |
 
   Scenario: Basic example
     Given a file named "basic_example_spec.rb" with:
@@ -38,12 +40,37 @@ Feature: Matching arguments
       """
     When I run `rspec basic_example_spec.rb`
     Then it should fail with the following output:
-      | 2 examples, 1 failure                            |
-      |                                                  |
-      | Failure/Error: dbl.foo(1, nil, "other")          |
-      |   Double received :foo with unexpected arguments |
-      |     expected: (1, anything, /bar/)               |
-      |          got: (1, nil, "other")                  |
+      | 2 examples, 1 failure                                           |
+      |                                                                 |
+      | Failure/Error: dbl.foo(1, nil, "other")                         |
+      |   #<Double (anonymous)> received :foo with unexpected arguments |
+      |     expected: (1, anything, /bar/)                              |
+      |          got: (1, nil, "other")                                 |
+
+  Scenario: Using a RSpec matcher
+    Given a file named "rspec_matcher_spec.rb" with:
+      """ruby
+      RSpec.describe "Using a RSpec matcher" do
+        let(:dbl) { double }
+        before { expect(dbl).to receive(:foo).with(a_collection_containing_exactly(1, 2)) }
+
+        it "passes when the args match" do
+          dbl.foo([2, 1])
+        end
+
+        it "fails when the args do not match" do
+          dbl.foo([1, 3])
+        end
+      end
+      """
+    When I run `rspec rspec_matcher_spec.rb`
+    Then it should fail with the following output:
+      | 2 examples, 1 failure                                         |
+      |                                                               |
+      | Failure/Error: dbl.foo([1, 3])                                |
+      | #<Double (anonymous)> received :foo with unexpected arguments |
+      | expected: (a collection containing exactly 1 and 2)           |
+      | got: ([1, 3])                                                 |
 
   Scenario: Using a custom matcher
     Given a file named "custom_matcher_spec.rb" with:
@@ -67,12 +94,12 @@ Feature: Matching arguments
       """
     When I run `rspec custom_matcher_spec.rb`
     Then it should fail with the following output:
-      | 2 examples, 1 failure                            |
-      |                                                  |
-      | Failure/Error: dbl.foo(13)                       |
-      |   Double received :foo with unexpected arguments |
-      |     expected: (a multiple of 3)                  |
-      |          got: (13)                               |
+      | 2 examples, 1 failure                                           |
+      |                                                                 |
+      | Failure/Error: dbl.foo(13)                                      |
+      |   #<Double (anonymous)> received :foo with unexpected arguments |
+      |     expected: (a multiple of 3)                                 |
+      |          got: (13)                                              |
 
   Scenario: Responding differently based on the arguments
     Given a file named "responding_differently_spec.rb" with:

data/rspec-mocks/upstream/features/setting_constraints/message_order.feature

@@ -56,8 +56,8 @@ Feature: Message Order
     Then the examples should all fail, producing the following output:
       |  1) Constraining order fails when messages are received out of order on one collaborator   |
       |     Failure/Error: collaborator_1.step_2                                                   |
-      |       Double "Collaborator 1" received :step_2 out of order                                |
+      |       #<Double "Collaborator 1"> received :step_2 out of order                             |
       |                                                                                            |
       |  2) Constraining order fails when messages are received out of order between collaborators |
       |     Failure/Error: collaborator_2.step_2                                                   |
-      |       Double "Collaborator 2" received :step_2 out of order                                |
+      |       #<Double "Collaborator 2"> received :step_2 out of order                             |

data/rspec-mocks/upstream/features/setting_constraints/receive_counts.feature

@@ -5,12 +5,15 @@ Feature: Receive Counts
 
     * `expect(...).to receive(...).once`
     * `expect(...).to receive(...).twice`
+    * `expect(...).to receive(...).exactly(n).time`
     * `expect(...).to receive(...).exactly(n).times`
     * `expect(...).to receive(...).at_least(:once)`
     * `expect(...).to receive(...).at_least(:twice)`
+    * `expect(...).to receive(...).at_least(n).time`
     * `expect(...).to receive(...).at_least(n).times`
     * `expect(...).to receive(...).at_most(:once)`
     * `expect(...).to receive(...).at_most(:twice)`
+    * `expect(...).to receive(...).at_most(n).time`
     * `expect(...).to receive(...).at_most(n).times`
 
   If you don't specify an expected receive count, it defaults to `once`.
@@ -49,6 +52,11 @@ Feature: Receive Counts
           account.open
         end
 
+        example "exactly(n).time" do
+          expect(logger).to receive(:account_opened).exactly(1).time
+          account.open
+        end
+
         example "exactly(n).times" do
           expect(logger).to receive(:account_opened).exactly(3).times
           account.open
@@ -69,6 +77,11 @@ Feature: Receive Counts
           account.open
         end
 
+        example "at_least(n).time" do
+          expect(logger).to receive(:account_opened).at_least(1).time
+          account.open
+        end
+
         example "at_least(n).times" do
           expect(logger).to receive(:account_opened).at_least(3).times
           account.open
@@ -86,6 +99,11 @@ Feature: Receive Counts
           account.open
         end
 
+        example "at_most(n).time" do
+          expect(logger).to receive(:account_opened).at_most(1).time
+          account.open
+        end
+
         example "at_most(n).times" do
           expect(logger).to receive(:account_opened).at_most(3).times
           account.open

data/rspec-mocks/upstream/features/step_definitions/additional_cli_steps.rb

@@ -1,10 +1,10 @@
 Then /^the example(?:s)? should(?: all)? pass$/ do
-  step %q{the output should contain "0 failures"}
-  step %q{the exit status should be 0}
+  step %q(the output should contain "0 failures")
+  step %q(the exit status should be 0)
 end
 
 Then /^the examples should all fail, producing the following output:$/ do |table|
-  step %q{the exit status should be 1}
+  step %q(the exit status should be 1)
   examples, failures = all_output.match(/(\d+) examples?, (\d+) failures?/).captures.map(&:to_i)
 
   expect(examples).to be > 0
@@ -15,7 +15,7 @@ Then /^the examples should all fail, producing the following output:$/ do |table
 end
 
 Then /^it should fail with the following output:$/ do |table|
-  step %q{the exit status should be 1}
+  step %q(the exit status should be 1)
   lines = table.raw.flatten.reject(&:empty?)
   expect(all_output).to include(*lines)
 end

data/rspec-mocks/upstream/features/support/disallow_certain_apis.rb

@@ -3,8 +3,9 @@
 
 if defined?(Cucumber)
   require 'shellwords'
-  Before('~@allow-old-syntax') do
-    set_env('SPEC_OPTS', "-r#{Shellwords.escape(__FILE__)}")
+  tag = !defined?(::RUBY_ENGINE_VERSION) || (::RUBY_ENGINE_VERSION < '2.0.0') ? '~@allow-old-syntax' : 'not @allow-old-syntax'
+  Before(tag) do
+    set_environment_variable('SPEC_OPTS', "-r#{Shellwords.escape(__FILE__)}")
   end
 else
   module DisallowOneLinerShould

data/rspec-mocks/upstream/features/support/env.rb

@@ -1,22 +1,22 @@
 require 'aruba/cucumber'
 require 'rspec/expectations'
 
-Before do
-  if RUBY_PLATFORM =~ /java/ || defined?(Rubinius)
-    @aruba_timeout_seconds = 60
+Aruba.configure do |config|
+  if RUBY_PLATFORM =~ /java/ || defined?(Rubinius) || (defined?(RUBY_ENGINE) && RUBY_ENGINE == 'truffleruby')
+    config.exit_timeout = 60
   else
-    @aruba_timeout_seconds = 5
+    config.exit_timeout = 5
   end
 end
 
-Aruba.configure do |config|
-  config.before_cmd do |cmd|
-    set_env('JRUBY_OPTS', "-X-C #{ENV['JRUBY_OPTS']}") # disable JIT since these processes are so short lived
+Before do
+  if RUBY_PLATFORM == 'java'
+    # disable JIT since these processes are so short lived
+    set_environment_variable('JRUBY_OPTS', "-X-C #{ENV['JRUBY_OPTS']}")
   end
-end if RUBY_PLATFORM == 'java'
 
-Aruba.configure do |config|
-  config.before_cmd do |cmd|
-    set_env('RBXOPT', "-Xint=true #{ENV['RBXOPT']}") # disable JIT since these processes are so short lived
+  if defined?(Rubinius)
+    # disable JIT since these processes are so short lived
+    set_environment_variable('RBXOPT', "-Xint=true #{ENV['RBXOPT']}")
   end
-end if defined?(Rubinius)
+end

data/rspec-mocks/upstream/features/support/rubinius.rb

@@ -1,6 +1,6 @@
 # Required until https://github.com/rubinius/rubinius/issues/2430 is resolved
 ENV['RBXOPT'] = "#{ENV["RBXOPT"]} -Xcompiler.no_rbc"
 
-Around "@unsupported-on-rbx" do |scenario, block|
+Around "@unsupported-on-rbx" do |_scenario, block|
   block.call unless defined?(Rubinius)
 end

data/rspec-mocks/upstream/features/verifying_doubles/README.md

@@ -1,7 +1,7 @@
 Verifying doubles are a stricter alternative to [normal doubles](./basics/test-doubles) that provide guarantees about
 what is being verified. When using verifying doubles, RSpec will check that the methods
 being stubbed are actually present on the underlying object if it is available. Prefer using
-veryifing doubles over normal doubles.
+verifying doubles over normal doubles.
 
 No checking will happen if the underlying object or class is not defined, but when run with
 it present (either as a full spec run or by explicitly preloading collaborators) a failure will be
@@ -10,4 +10,4 @@ number of arguments.
 
 This dual approach allows you to move very quickly and test components in isolation, while
 giving you confidence that your doubles are not a complete fiction. Testing in isolation is
-optional but recommend for classes that do not depend on third-party components.
+optional but recommended for classes that do not depend on third-party components.

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

@@ -67,4 +67,4 @@ Feature: Using a class double
       """
     When I run `rspec spec/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 "the ConsoleNotifier class does not implement the class method:"

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

@@ -2,13 +2,16 @@ Feature: Dynamic classes
 
   Verifying instance doubles do not support methods which the class reports to not exist
   since an actual instance of the class would be required to verify against. This is commonly
-  the case when `method_missing` is used. For example, `ActiveRecord` does this to define
-  methods from database columns.
+  the case when `method_missing` is used.
 
   There are a few ways to work around this. If the object has already been loaded you may
-  consider using an [`object_double`](./using-an-object-double), but that cannot work if you
-  are testing in isolation. Alternatively you could implement the methods directly (calling
-  `super` to return the `method_missing` definition).
+  consider using an [`object_double`](./using-an-object-double), but that cannot work if you are testing in isolation.
+  Alternatively you could implement the methods directly (calling `super` to return the `method_missing` definition).
+
+  Some of these classes may have methods to define these methods on the objects at runtime.
+  (For example, `ActiveRecord` does this to define methods from database columns.) For these
+  cases we provide an API which can be used to customise verifying doubles on creation. We
+  use this ourselves in `rspec-rails` to set up some niceties for you.
 
   These types of methods are supported at class level (with `class_double`) however, since
   `respond_to?` can be queried directly on the class.
@@ -30,6 +33,12 @@ Feature: Dynamic classes
             super
           end
         end
+
+        def self.define_attribute_methods
+          COLUMNS.each do |name|
+            define_method(name) { instance_variable_get("@#{name}") }
+          end
+        end
       end
       """
 
@@ -71,3 +80,30 @@ Feature: Dynamic classes
 
     When I run `rspec spec/user_spec.rb`
     Then the examples should all pass
+
+  Scenario: workaround using callback
+
+    Given a file named "lib/user.rb" with:
+      """ruby
+      require 'fake_active_record'
+
+      class User < FakeActiveRecord
+      end
+      """
+    And a file named "spec/fake_record_helper.rb" with:
+      """ruby
+      RSpec.configuration.mock_with(:rspec) do |config|
+        config.before_verifying_doubles do |reference|
+          reference.target.define_attribute_methods
+        end
+      end
+      #
+      # or you can use:
+      #
+      # RSpec::Mocks.configuration.before_verifying_doubles do |reference|
+      #   reference.target.define_attribute_methods
+      # end
+      """
+
+    When I run `rspec -r fake_record_helper spec/user_spec.rb`
+    Then the examples should all pass