opal-rspec 0.8.0.alpha3 → 1.0.0.alpha1

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

@@ -92,8 +92,8 @@ Feature: Scope
       """
     When I run `rspec leak_test_double_spec.rb`
     Then it should fail with the following output:
-      | 2 examples, 1 failure                                                                                                      |
-      |                                                                                                                            |
-      |  1) Account keeps track of the balance                                                                                     |
-      |     Failure/Error: self.class.logger.log("Credited $#{amount}")                                                            |
-      |       Double "Logger" was originally created in one example but has leaked into another example and can no longer be used. |
+      | 2 examples, 1 failure                                                                                                         |
+      |                                                                                                                               |
+      |  1) Account keeps track of the balance                                                                                        |
+      |     Failure/Error: self.class.logger.log("Credited $#{amount}")                                                               |
+      |       #<Double "Logger"> was originally created in one example but has leaked into another example and can no longer be used. |

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

@@ -1,7 +1,7 @@
 Feature: Spies
 
   [Message expectations](./expecting-messages) put an example's expectation at the start, before you've invoked the
-  code-under-test. Many developers prefer using an act-arrange-assert (or given-when-then)
+  code-under-test. Many developers prefer using an arrange-act-assert (or given-when-then)
   pattern for structuring tests. Spies are an alternate type of test double that support this
   pattern by allowing you to expect that a message has been received after the fact, using
   `have_received`.
@@ -13,6 +13,7 @@ Feature: Spies
   `have_received` supports the same fluent interface for [setting constraints](../setting-constraints) that normal message expectations do.
 
   Note: The `have_received` API shown here will only work if you are using rspec-expectations.
+  Note: `have_received(...).with(...)` is unable to work properly when passed arguments are mutated after the spy records the received message.
 
   Scenario: Using a spy
     Given a file named "spy_spec.rb" with:
@@ -70,7 +71,8 @@ Feature: Spies
       """
         1) failure when the message has not been received for a spy
            Failure/Error: expect(invitation).to have_received(:deliver)
-             (Double "invitation").deliver(any args)
+
+             (Double "invitation").deliver(*(any args))
                  expected: 1 time with any arguments
                  received: 0 times with any arguments
       """
@@ -78,7 +80,8 @@ Feature: Spies
       """
         2) failure when the message has not been received for a partial double
            Failure/Error: expect(Invitation).to have_received(:deliver)
-             (<Invitation (class)>).deliver(any args)
+
+             (Invitation (class)).deliver(*(any args))
                  expected: 1 time with any arguments
                  received: 0 times with any arguments
       """
@@ -115,30 +118,14 @@ Feature: Spies
       """
     When I run `rspec setting_constraints_spec.rb --order defined`
     Then it should fail with the following output:
-      | 4 examples, 2 failures                                                                           |
-      |                                                                                                  |
-      |  1) An invitiation fails when a count constraint is not satisfied                                |
-      |     Failure/Error: expect(invitation).to have_received(:deliver).at_least(3).times               |
-      |       (Double "invitation").deliver(any args)                                                    |
-      |           expected: at least 3 times with any arguments                                          |
-      |           received: 2 times with any arguments                                                   |
-      |                                                                                                  |
-      |  2) An invitiation fails when an order constraint is not satisifed                               |
-      |     Failure/Error: expect(invitation).to have_received(:deliver).with("foo@example.com").ordered |
-      |       Double "invitation" received :deliver out of order                                         |
-
-  Scenario: `have_received` generates a good example description
-    Given a file named "generates_description_spec.rb" with:
-      """ruby
-      RSpec.describe "An invitation" do
-        subject(:invitation) { spy('invitation') }
-        before { invitation.deliver }
-        it { is_expected.to have_received(:deliver) }
-      end
-      """
-    When I run `rspec --format documentation generates_description_spec.rb`
-    Then it should pass with:
-      """
-      An invitation
-        should have received deliver(any args) 1 time
-      """
+      | 4 examples, 2 failures                                                                              |
+      |                                                                                                     |
+      |  1) An invitiation fails when a count constraint is not satisfied                                   |
+      |     Failure/Error: expect(invitation).to have_received(:deliver).at_least(3).times                  |
+      |       (Double "invitation").deliver(*(any args))                                                    |
+      |           expected: at least 3 times with any arguments                                             |
+      |           received: 2 times with any arguments                                                      |
+      |                                                                                                     |
+      |  2) An invitiation fails when an order constraint is not satisifed                                  |
+      |     Failure/Error: expect(invitation).to have_received(:deliver).with("foo@example.com").ordered    |
+      |       #<Double "invitation"> received :deliver out of order                                         |

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

@@ -13,7 +13,7 @@ Feature: Test Doubles
   Scenario: Doubles are strict by default
     Given a file named "double_spec.rb" with:
       """ruby
-      RSpec.describe "double" do
+      RSpec.describe "A test double" do
         it "raises errors when messages not allowed or expected are received" do
           dbl = double("Some Collaborator")
           dbl.foo
@@ -23,14 +23,14 @@ Feature: Test Doubles
      When I run `rspec double_spec.rb`
      Then it should fail with:
       """
-      Double "Some Collaborator" received unexpected message :foo with (no args)
+      #<Double "Some Collaborator"> received unexpected message :foo with (no args)
       """
 
   Scenario: A hash can be used to define allowed messages and return values
     Given a file named "double_spec.rb" with:
       """ruby
-      RSpec.describe "double" do
-        it "raises errors when messages not allowed or expected are received" do
+      RSpec.describe "A test double" do
+        it "returns canned responses from the methods named in the provided hash" do
           dbl = double("Some Collaborator", :foo => 3, :bar => 4)
           expect(dbl.foo).to eq(3)
           expect(dbl.bar).to eq(4)

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

@@ -3,9 +3,11 @@ methods are provided to configure how the test double responds to the message.
 
 * <a href="./configuring-responses/returning-a-value">`and_return`</a>
 * <a href="./configuring-responses/raising-an-error">`and_raise`</a>
+* <a href="./configuring-responses/mixed-responses">`and_invoke`</a>
 * <a href="./configuring-responses/throwing">`and_throw`</a>
 * <a href="./configuring-responses/yielding">`and_yield`</a>
 * <a href="./configuring-responses/calling-the-original-implementation">`and_call_original`</a>
+* <a href="./configuring-responses/wrapping-the-original-implementation">`and_wrap_original`</a>
 
 In addition, you can provide a [block implementation](./configuring-responses/block-implementation) to respond in any manner you wish.
 

data/rspec-mocks/upstream/features/configuring_responses/calling_the_original_implementation.feature

@@ -33,13 +33,13 @@ Feature: Calling the original implementation
     When I run `rspec spec/and_call_original_spec.rb`
     Then the examples should all pass
 
-  Scenario: `and_call_original` can configure a default response that can be overriden for specific args
+  Scenario: `and_call_original` can configure a default response that can be overridden for specific args
     Given a file named "spec/and_call_original_spec.rb" with:
       """ruby
       require 'calculator'
 
       RSpec.describe "and_call_original" do
-        it "can be overriden for specific arguments using #with" do
+        it "can be overridden for specific arguments using #with" do
           allow(Calculator).to receive(:add).and_call_original
           allow(Calculator).to receive(:add).with(2, 3).and_return(-5)
 

data/rspec-mocks/upstream/features/configuring_responses/mixed_responses.feature

@@ -0,0 +1,25 @@
+Feature: Mixed responses
+
+  Use `and_invoke` to invoke a callable when a message is received. Pass `and_invoke` multiple
+  callables to have different behavior for consecutive calls. The final callable will continue to be
+  called if the message is received additional times.
+
+  Note: The invoked callable will be invoked with the calls arguments, so it is recommended to
+  use a `lambda` or similar with the same arity as your method but you can use a `proc` if you
+  do not care about arity (e.g. when raising).
+
+  Scenario: Mixed responses
+    Given a file named "raises_and_then_returns.rb" with:
+      """ruby
+      RSpec.describe "when the method is called multiple times" do
+        it "raises and then later returns a value" do
+          dbl = double
+          allow(dbl).to receive(:foo).and_invoke(lambda { raise "failure" }, lambda { true })
+
+          expect { dbl.foo }.to raise_error("failure")
+          expect(dbl.foo).to eq(true)
+        end
+      end
+      """
+     When I run `rspec raises_and_then_returns.rb`
+     Then the examples should all pass

data/rspec-mocks/upstream/features/configuring_responses/raising_an_error.feature

@@ -23,6 +23,7 @@ Feature: Raising an error
       """
         1) Making it raise an error raises the provided exception
            Failure/Error: dbl.foo
+
            RuntimeError:
              boom
       """

data/rspec-mocks/upstream/features/configuring_responses/wrapping_the_original_implementation.feature

@@ -1,7 +1,7 @@
 Feature: Wrapping the original implementation
 
   Use `and_wrap_original` to modify a partial double's original response. This can be useful
-  when you want to utilise an external object but mutate it's response. For example if an
+  when you want to utilise an external object but mutate its response. For example if an
   API returns a large amount of data and for test purposes you'd like to trim it down. You can
   also use it to configure the default response for most arguments, and then override that for
   specific arguments using `with`.
@@ -34,13 +34,13 @@ Feature: Wrapping the original implementation
     When I run `rspec spec/and_wrap_original_spec.rb`
     Then the examples should all pass
 
-  Scenario: `and_wrap_original` can configure a default response that can be overriden for specific args
+  Scenario: `and_wrap_original` can configure a default response that can be overridden for specific args
     Given a file named "spec/and_wrap_original_spec.rb" with:
       """ruby
       require 'api'
 
       RSpec.describe "and_wrap_original" do
-        it "can be overriden for specific arguments using #with" do
+        it "can be overridden for specific arguments using #with" do
           allow(API).to receive(:solve_for).and_wrap_original { |m, *args| m.call(*args).first(5) }
           allow(API).to receive(:solve_for).with(2).and_return([3])
 

data/rspec-mocks/upstream/features/configuring_responses/yielding.feature

@@ -37,7 +37,7 @@ Feature: Yielding
      When I run `rspec no_caller_block_spec.rb`
      Then it should fail with:
       """
-      Double asked to yield |[2, 3]| but no block was passed
+      #<Double (anonymous)> asked to yield |[2, 3]| but no block was passed
       """
 
   Scenario: It fails when the caller's block does not accept the provided arguments
@@ -54,7 +54,7 @@ Feature: Yielding
      When I run `rspec arg_mismatch_spec.rb`
      Then it should fail with:
       """
-      Double yielded |2, 3| to block with arity of 1
+      #<Double (anonymous)> yielded |2, 3| to block with arity of 1
       """
 
   Scenario: Yield multiple times

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

@@ -66,7 +66,7 @@ restored to its original value after the test completes.
 ```ruby
 FOO = 42
 hide_const("FOO")
-FOO => NameError: uninitialized constant FOO
+FOO # => NameError: uninitialized constant FOO
 ```
 
 Like stubbed constants, names must be fully qualified.

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

@@ -71,11 +71,11 @@ Feature: `any_instance`
       """ruby
       RSpec.describe "Stubbing any instance of a class" do
         it 'yields the receiver to the block implementation' do
-          Array.any_instance.stub(:shuffle) do |array|
-            array.unshift(array.pop)
+          String.any_instance.stub(:slice) do |value, start, length|
+            value[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/old_syntax/should_receive.feature

@@ -36,7 +36,8 @@ Feature: `should_receive`
       """
         1) An unfulfilled message expectation triggers a failure
            Failure/Error: dbl.should_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
       """
@@ -71,6 +72,7 @@ Feature: `should_receive`
       """
         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

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

@@ -0,0 +1,116 @@
+Feature: Integrate with any test framework
+
+  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.
+
+  Note: if you are using minitest, you'll probably want to use the built-in [minitest integration](./integrate-with-minitest).
+
+  Scenario: Use rspec-mocks with Minitest
+    Given a file named "test/test_helper.rb" with:
+      """ruby
+      require 'minitest/autorun'
+      require 'rspec/mocks'
+
+      module MinitestRSpecMocksIntegration
+        include ::RSpec::Mocks::ExampleMethods
+
+        def before_setup
+          ::RSpec::Mocks.setup
+          super
+        end
+
+        def after_teardown
+          super
+          ::RSpec::Mocks.verify
+        ensure
+          ::RSpec::Mocks.teardown
+        end
+      end
+
+      Minitest::Test.send(:include, MinitestRSpecMocksIntegration)
+      """
+    And a file named "test/rspec_mocks_test.rb" with:
+      """ruby
+      require 'test_helper'
+
+      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
+
+        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 test_passing_negative_spy_expectation
+          bond = spy
+          expect(bond).not_to have_received(:james)
+        end
+
+        def test_failing_negative_spy_expectation
+          bond = spy
+          bond.james
+          expect(bond).not_to have_received(:james)
+        end
+      end
+      """
+     When I run `ruby -Itest test/rspec_mocks_test.rb`
+     Then it should fail with the following output:
+       |   1) Error:                                                                   |
+       | RSpecMocksTest#test_failing_negative_expectation:                             |
+       | RSpec::Mocks::MockExpectationError: (Double (anonymous)).message(no args)     |
+       |     expected: 0 times with any arguments                                      |
+       |     received: 1 time                                                          |
+       |                                                                               |
+       |   2) Error:                                                                   |
+       | RSpecMocksTest#test_failing_positive_expectation:                             |
+       | RSpec::Mocks::MockExpectationError: (Double (anonymous)).message(*(any args)) |
+       |     expected: 1 time with any arguments                                       |
+       |     received: 0 times with any arguments                                      |
+       |                                                                               |
+       |   3) Error:                                                                   |
+       | RSpecMocksTest#test_failing_positive_spy_expectation:                         |
+       | RSpec::Mocks::MockExpectationError: (Double (anonymous)).james(*(any args))   |
+       |     expected: 1 time with any arguments                                       |
+       |     received: 0 times with any arguments                                      |
+       |                                                                               |
+       |   4) Error:                                                                   |
+       | RSpecMocksTest#test_failing_negative_spy_expectation:                         |
+       | RSpec::Mocks::MockExpectationError: (Double (anonymous)).james(no args)       |
+       |     expected: 0 times with any arguments                                      |
+       |     received: 1 time                                                          |
+       |                                                                               |
+       |  8 runs, 0 assertions, 0 failures, 4 errors, 0 skips                          |