opal-rspec 0.7.0.rc.1 → 0.7.0.rc.2

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

@@ -0,0 +1,51 @@
+@allow-old-syntax
+Feature: `stub`
+
+  `stub` is the old way to [allow messages](../basics/allowing-messages) but carries the baggage of a
+  global monkey patch on all objects. It supports the same fluent
+  interface for [setting constraints](../setting-constraints) and [configuring responses](../configuring-responses). You can also pass `stub` a hash
+  of message/return-value pairs, which acts like `allow(obj).to receive_messages(hash)`,
+  but does not support further customization through the fluent interface.
+
+  Background:
+    Given a file named "spec/spec_helper.rb" with:
+      """ruby
+      RSpec.configure do |config|
+        config.mock_with :rspec do |mocks|
+          mocks.syntax = :should
+        end
+      end
+      """
+    And a file named ".rspec" with:
+      """
+      --require spec_helper
+      """
+
+  Scenario: Stub a method
+    Given a file named "spec/stub_spec.rb" with:
+      """ruby
+      RSpec.describe "Stubbing a method" do
+        it "configures how the object responds" do
+          dbl = double
+          dbl.stub(:foo).and_return(13)
+          expect(dbl.foo).to eq(13)
+        end
+      end
+      """
+    When I run `rspec spec/stub_spec.rb`
+    Then the examples should all pass
+
+  Scenario: Stub multiple methods by passing a hash
+    Given a file named "spec/stub_multiple_methods_spec.rb" with:
+      """ruby
+      RSpec.describe "Stubbing multiple methods" do
+        it "stubs each named method with the given return value" do
+          dbl = double
+          dbl.stub(:foo => 13, :bar => 10)
+          expect(dbl.foo).to eq(13)
+          expect(dbl.bar).to eq(10)
+        end
+      end
+      """
+    When I run `rspec spec/stub_multiple_methods_spec.rb`
+    Then the examples should all pass

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

@@ -0,0 +1,69 @@
+@allow-old-syntax
+Feature: `stub_chain`
+
+  `stub_chain` is the old way to [allow a message chain](../working-with-legacy-code/message-chains) but carries the
+  baggage of a global monkey patch on all objects. As with
+  `receive_message_chain`, use with care; we recommend treating usage of `stub_chain` as a
+  code smell.
+
+  Background:
+    Given a file named "spec/spec_helper.rb" with:
+      """ruby
+      RSpec.configure do |config|
+        config.mock_with :rspec do |mocks|
+          mocks.syntax = :should
+        end
+      end
+      """
+    And a file named ".rspec" with:
+      """
+      --require spec_helper
+      """
+
+  Scenario: Use `stub_chain` on a double
+    Given a file named "spec/stub_chain_spec.rb" with:
+      """ruby
+      RSpec.describe "Using stub_chain on a double" do
+        let(:dbl) { double }
+
+        example "using a string and a block" do
+          dbl.stub_chain("foo.bar") { :baz }
+          expect(dbl.foo.bar).to eq(:baz)
+        end
+
+        example "using symbols and a hash" do
+          dbl.stub_chain(:foo, :bar => :baz)
+          expect(dbl.foo.bar).to eq(:baz)
+        end
+
+        example "using symbols and a block" do
+          dbl.stub_chain(:foo, :bar) { :baz }
+          expect(dbl.foo.bar).to eq(:baz)
+        end
+      end
+      """
+    When I run `rspec spec/stub_chain_spec.rb`
+    Then the examples should all pass
+
+  Scenario: Use `stub_chain` on any instance of a class
+    Given a file named "spec/stub_chain_spec.rb" with:
+      """ruby
+      RSpec.describe "Using any_instance.stub_chain" do
+        example "using a string and a block" do
+          Object.any_instance.stub_chain("foo.bar") { :baz }
+          expect(Object.new.foo.bar).to eq(:baz)
+        end
+
+        example "using symbols and a hash" do
+          Object.any_instance.stub_chain(:foo, :bar => :baz)
+          expect(Object.new.foo.bar).to eq(:baz)
+        end
+
+        example "using symbols and a block" do
+          Object.any_instance.stub_chain(:foo, :bar) { :baz }
+          expect(Object.new.foo.bar).to eq(:baz)
+        end
+      end
+      """
+    When I run `rspec spec/stub_chain_spec.rb`
+    Then the examples should all pass

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

@@ -0,0 +1,43 @@
+@allow-old-syntax
+Feature: `unstub`
+
+  `unstub` removes a method stub, essentially cleaning up the method
+  stub early, rather than waiting for the cleanup that runs at the end
+  of the example. The newer non-monkey-patching syntax does not have a direct
+  equivalent but in most situations you can achieve the same behavior using
+  [`and_call_original`](../configuring-responses/calling-the-original-implementation). The difference is that `obj.unstub(:foo)` completely cleans up the `foo`
+  method stub, whereas `allow(obj).to receive(:foo).and_call_original` continues to
+  observe calls to the method (important when you are using [spies](../basics/spies)), which could affect the
+  method's behavior if it does anything with `caller` as it will include additional rspec stack
+  frames.
+
+  Background:
+    Given a file named "spec/spec_helper.rb" with:
+      """ruby
+      RSpec.configure do |config|
+        config.mock_with :rspec do |mocks|
+          mocks.syntax = :should
+        end
+      end
+      """
+    And a file named ".rspec" with:
+      """
+      --require spec_helper
+      """
+
+  Scenario: Unstub a method
+    Given a file named "spec/unstub_spec.rb" with:
+      """ruby
+      RSpec.describe "Unstubbing a method" do
+        it "restores the original behavior" do
+          string = "hello world"
+          string.stub(:reverse) { "hello dlrow" }
+
+          expect {
+            string.unstub(:reverse)
+          }.to change { string.reverse }.from("hello dlrow").to("dlrow olleh")
+        end
+      end
+      """
+    When I run `rspec spec/unstub_spec.rb`
+    Then the examples should all pass

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

@@ -0,0 +1,80 @@
+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:
+      """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
+      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).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           |

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

@@ -0,0 +1,33 @@
+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.
+
+  Scenario: Allow a message outside RSpec
+    Given a file named "example.rb" with:
+      """ruby
+      require "rspec/mocks/standalone"
+
+      greeter = double("greeter")
+      allow(greeter).to receive(:say_hi) { "Hello!" }
+      puts greeter.say_hi
+      """
+    When I run `ruby example.rb`
+    Then the output should contain "Hello!"
+
+  Scenario: Expect a message outside RSpec
+    Given a file named "example.rb" with:
+      """ruby
+      require "rspec/mocks/standalone"
+
+      greeter = double("greeter")
+      expect(greeter).to receive(:say_hi)
+
+      RSpec::Mocks.verify
+      """
+    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 |

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

@@ -0,0 +1,6 @@
+RSpec provides a fluent interface off of `expect(...).to receive(...)` that allows you to
+further constrain what you expect: the arguments, the number of times, and the ordering of
+multiple messages.
+
+Although not shown here, this fluent interface is also supported by [spies](./basics/spies), off of
+`have_received(...)`.

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

@@ -0,0 +1,97 @@
+Feature: Matching arguments
+
+  Use `with` to specify the expected arguments. A [message expectation](../basics/expecting-messages) constrained by `with`
+  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>)`          |
+
+  Scenario: Basic example
+    Given a file named "basic_example_spec.rb" with:
+      """ruby
+      RSpec.describe "Constraining a message expectation using with" do
+        let(:dbl) { double }
+        before { expect(dbl).to receive(:foo).with(1, anything, /bar/) }
+
+        it "passes when the args match" do
+          dbl.foo(1, nil, "barn")
+        end
+
+        it "fails when the args do not match" do
+          dbl.foo(1, nil, "other")
+        end
+      end
+      """
+    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")                  |
+
+  Scenario: Using a custom matcher
+    Given a file named "custom_matcher_spec.rb" with:
+      """ruby
+      RSpec::Matchers.define :a_multiple_of do |x|
+        match { |actual| (actual % x).zero? }
+      end
+
+      RSpec.describe "Using a custom matcher" do
+        let(:dbl) { double }
+        before { expect(dbl).to receive(:foo).with(a_multiple_of(3)) }
+
+        it "passes when the args match" do
+          dbl.foo(12)
+        end
+
+        it "fails when the args do not match" do
+          dbl.foo(13)
+        end
+      end
+      """
+    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)                               |
+
+  Scenario: Responding differently based on the arguments
+    Given a file named "responding_differently_spec.rb" with:
+      """ruby
+      RSpec.describe "Using #with to constrain responses" do
+        specify "its response depends on the arguments" do
+          dbl = double
+
+          # Set a default for any unmatched args
+          allow(dbl).to receive(:foo).and_return(:default)
+
+          allow(dbl).to receive(:foo).with(1).and_return(1)
+          allow(dbl).to receive(:foo).with(2).and_return(2)
+
+          expect(dbl.foo(0)).to eq(:default)
+          expect(dbl.foo(1)).to eq(1)
+          expect(dbl.foo(2)).to eq(2)
+        end
+      end
+      """
+    When I run `rspec responding_differently_spec.rb`
+    Then the examples should all pass

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

@@ -0,0 +1,63 @@
+Feature: Message Order
+
+  You can use `ordered` to constrain the order of multiple message expectations. This is not
+  generally recommended because in most situations the order doesn't matter and using
+  `ordered` would make your spec brittle, but it's occasionally useful. When you use `ordered`,
+  the example will only pass if the messages are received in the declared order.
+
+  Scenario: Passing example
+    Given a file named "passing_example_spec.rb" with:
+      """ruby
+      RSpec.describe "Constraining order" do
+        it "passes when the messages are received in declared order" do
+          collaborator_1 = double("Collaborator 1")
+          collaborator_2 = double("Collaborator 2")
+
+          expect(collaborator_1).to receive(:step_1).ordered
+          expect(collaborator_2).to receive(:step_2).ordered
+          expect(collaborator_1).to receive(:step_3).ordered
+
+          collaborator_1.step_1
+          collaborator_2.step_2
+          collaborator_1.step_3
+        end
+      end
+      """
+    When I run `rspec passing_example_spec.rb`
+    Then the examples should all pass
+
+  Scenario: Failing examples
+    Given a file named "failing_examples_spec.rb" with:
+      """ruby
+      RSpec.describe "Constraining order" do
+        it "fails when messages are received out of order on one collaborator" do
+          collaborator_1 = double("Collaborator 1")
+
+          expect(collaborator_1).to receive(:step_1).ordered
+          expect(collaborator_1).to receive(:step_2).ordered
+
+          collaborator_1.step_2
+          collaborator_1.step_1
+        end
+
+        it "fails when messages are received out of order between collaborators" do
+          collaborator_1 = double("Collaborator 1")
+          collaborator_2 = double("Collaborator 2")
+
+          expect(collaborator_1).to receive(:step_1).ordered
+          expect(collaborator_2).to receive(:step_2).ordered
+
+          collaborator_2.step_2
+          collaborator_1.step_1
+        end
+      end
+      """
+    When I run `rspec failing_examples_spec.rb --order defined`
+    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                                |
+      |                                                                                            |
+      |  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                                |