rspec-mocks 3.0.0.beta2 → 3.0.0.rc1

data/features/method_stubs/stub_implementation.feature

@@ -1,48 +0,0 @@
-Feature: stub with substitute implementation
-
-  You can stub an implementation of a method (a.k.a. fake) by passing a block
-  to the `stub` method.
-
-  Scenario: stub implementation using `expect` syntax
-  Given a file named "stub_implementation_spec.rb" with:
-    """ruby
-    describe "a stubbed implementation" do
-      it "works" do
-        object = Object.new
-        allow(object).to receive(:foo) do |arg|
-          if arg == :this
-            "got this"
-          elsif arg == :that
-            "got that"
-          end
-        end
-
-        expect(object.foo(:this)).to eq("got this")
-        expect(object.foo(:that)).to eq("got that")
-      end
-    end
-    """
-  When I run `rspec stub_implementation_spec.rb`
-  Then the output should contain "1 example, 0 failures"
-
-  Scenario: stub implementation using `should` syntax
-    Given a file named "stub_implementation_spec.rb" with:
-      """ruby
-      describe "a stubbed implementation" do
-        it "works" do
-          object = Object.new
-          object.stub(:foo) do |arg|
-            if arg == :this
-              "got this"
-            elsif arg == :that
-              "got that"
-            end
-          end
-
-          expect(object.foo(:this)).to eq("got this")
-          expect(object.foo(:that)).to eq("got that")
-        end
-      end
-      """
-    When I run `rspec stub_implementation_spec.rb`
-    Then the output should contain "1 example, 0 failures"

data/features/method_stubs/to_ary.feature

@@ -1,51 +0,0 @@
-Feature: double handling to_ary
-
-  Ruby implicitly sends `to_ary` to all of the objects in an `Array` when the
-  array receives `flatten`:
-
-      [obj].flatten # => obj.to_ary
-
-  If `to_ary` raises a `NoMethodError`, Ruby sees that the object can not be coerced
-  into an array and moves on to the next object.
-
-  To support this, an RSpec double will raise a NoMethodError when it receives
-  `to_ary` _even if it is set `as_null_object`_, unless `to_ary` is explicitly
-  stubbed.
-
-  Scenario: double receiving to_ary
-    Given a file named "example.rb" with:
-      """ruby
-      describe "#to_ary" do
-        shared_examples "to_ary" do
-          it "can be overridden with a stub" do
-            allow(obj).to receive(:to_ary) { :non_nil_value }
-            expect(obj.to_ary).to be(:non_nil_value)
-          end
-
-          it "supports Array#flatten" do
-            obj = double('foo')
-            expect([obj].flatten).to eq([obj])
-          end
-        end
-
-        context "sent to a double as_null_object" do
-          let(:obj) { double('obj').as_null_object }
-          include_examples "to_ary"
-
-          it "returns nil" do
-            expect( obj.to_ary ).to eq nil
-          end
-        end
-
-        context "sent to a double without as_null_object" do
-          let(:obj) { double('obj') }
-          include_examples "to_ary"
-
-          it "raises a NoMethodError" do
-            expect { obj.to_ary }.to raise_error(NoMethodError)
-          end
-        end
-      end
-     """
-    When I run `rspec example.rb`
-    Then the examples should all pass

data/features/mutating_constants/README.md

@@ -1,82 +0,0 @@
-## Mutating Constants
-
-### Stubbing
-
-Support is provided for stubbing constants. Like with method stubs, the
-stubbed constants will be restored to their original state when an
-example completes.
-
-``` ruby
-stub_const("Foo", fake_foo)
-Foo # => fake_foo
-```
-
-Stubbed constant names must be fully qualified; the current module
-nesting is not considered.
-
-``` ruby
-module MyGem
-  class SomeClass; end
-end
-
-module MyGem
-  describe "Something" do
-    let(:fake_class) { Class.new }
-
-    it "accidentally stubs the wrong constant" do
-      # this stubs ::SomeClass (in the top-level namespace),
-      # not MyGem::SomeClass like you probably mean.
-      stub_const("SomeClass", fake_class)
-    end
-
-    it "stubs the right constant" do
-      stub_const("MyGem::SomeClass", fake_class)
-    end
-  end
-end
-```
-
-When you stub a constant that is a module or a class, nested
-constants on the original module or class are not transferred
-by default, but you can use the `:transfer_nested_constants`
-option to tell rspec-mocks to transfer them:
-
-``` ruby
-class CardDeck
-  SUITS = [:Spades, :Diamonds, :Clubs, :Hearts]
-  NUM_CARDS = 52
-end
-
-fake_class = Class.new
-stub_const("CardDeck", fake_class)
-CardDeck # => fake_class
-CardDeck::SUITS # => raises uninitialized constant error
-CardDeck::NUM_CARDS # => raises uninitialized constant error
-
-stub_const("CardDeck", fake_class, :transfer_nested_constants => true)
-CardDeck::SUITS # => [:Spades, :Diamonds, :Clubs, :Hearts]
-CardDeck::NUM_CARDS # => 52
-
-stub_const("CardDeck", fake_class, :transfer_nested_constants => [:SUITS])
-CardDeck::SUITS # => [:Spades, :Diamonds, :Clubs, :Hearts]
-CardDeck::NUM_CARDS # => raises uninitialized constant error
-```
-
-### Hiding
-
-Support is also provided for hiding constants. Hiding a constant temporarily
-removes it; it is restored to its original value after the test completes.
-
-```ruby
-FOO = 42
-hide_const("FOO")
-FOO => NameError: uninitialized constant FOO
-```
-
-Like stubbed constants, names must be fully qualified.
-
-Hiding constants that are already undefined has no effect.
-
-```ruby
-hide_const("NO_OP")
-```

data/features/mutating_constants/hiding_defined_constant.feature

@@ -1,64 +0,0 @@
-Feature: Hide Defined Constant
-
-  Use `hide_const` to remove a constant for the duration of a test.
-
-  Scenario: Hide top-level constant
-    Given a file named "hide_const_spec.rb" with:
-      """ruby
-      FOO = 7
-
-      describe "hiding FOO" do
-        it "can hide FOO" do
-          hide_const("FOO")
-          expect { FOO }.to raise_error(NameError)
-        end
-
-        it "restores the hidden constant when the example completes" do
-          expect(FOO).to eq(7)
-        end
-      end
-      """
-    When I run `rspec hide_const_spec.rb`
-    Then the examples should all pass
-
-  Scenario: Hide nested constant
-    Given a file named "hide_const_spec.rb" with:
-      """ruby
-      module MyGem
-        class SomeClass
-          FOO = 7
-        end
-      end
-
-      module MyGem
-        describe SomeClass do
-          it "hides the nested constant when it is fully qualified" do
-            hide_const("MyGem::SomeClass::FOO")
-            expect { SomeClass::FOO }.to raise_error(NameError)
-          end
-
-          it "restores the hidden constant when the example completes" do
-            expect(MyGem::SomeClass::FOO).to eq(7)
-          end
-        end
-      end
-      """
-    When I run `rspec hide_const_spec.rb`
-    Then the examples should all pass
-
-  Scenario: Hiding undefined constant
-    Given a file named "hide_const_spec.rb" with:
-      """
-      describe "hiding UNDEFINED_CONSTANT" do
-        it "has no effect" do
-          hide_const("UNDEFINED_CONSTANT")
-          expect { UNDEFINED_CONSTANT }.to raise_error(NameError)
-        end
-
-        it "is still undefined after the example completes" do
-          expect { UNDEFINED_CONSTANT }.to raise_error(NameError)
-        end
-      end
-      """
-    When I run `rspec hide_const_spec.rb`
-    Then the examples should all pass

data/features/mutating_constants/stub_defined_constant.feature

@@ -1,78 +0,0 @@
-Feature: Stub Defined Constant
-
-  Use `stub_const` to stub constants. When the constant is already defined,
-  the stubbed value will replace the original value for the duration of the
-  example.
-
-  Scenario: Stub top-level constant
-    Given a file named "stub_const_spec.rb" with:
-      """ruby
-      FOO = 7
-
-      describe "stubbing FOO" do
-        it "can stub FOO with a different value" do
-          stub_const("FOO", 5)
-          expect(FOO).to eq(5)
-        end
-
-        it "restores the stubbed constant when the example completes" do
-          expect(FOO).to eq(7)
-        end
-      end
-      """
-    When I run `rspec stub_const_spec.rb`
-    Then the examples should all pass
-
-  Scenario: Stub nested constant
-    Given a file named "stub_const_spec.rb" with:
-      """ruby
-      module MyGem
-        class SomeClass
-          FOO = 7
-        end
-      end
-
-      module MyGem
-        describe SomeClass do
-          it "stubs the nested constant when it is fully qualified" do
-            stub_const("MyGem::SomeClass::FOO", 5)
-            expect(SomeClass::FOO).to eq(5)
-          end
-        end
-      end
-      """
-    When I run `rspec stub_const_spec.rb`
-    Then the examples should all pass
-
-  Scenario: Transfer nested constants
-    Given a file named "stub_const_spec.rb" with:
-      """ruby
-      module MyGem
-        class SomeClass
-          FOO = 7
-        end
-      end
-
-      module MyGem
-        describe SomeClass do
-          let(:fake_class) { Class.new }
-
-          it "does not transfer nested constants by default" do
-            stub_const("MyGem::SomeClass", fake_class)
-            expect { SomeClass::FOO }.to raise_error(NameError)
-          end
-
-          it "transfers nested constants when using :transfer_nested_constants => true" do
-            stub_const("MyGem::SomeClass", fake_class, :transfer_nested_constants => true)
-            expect(SomeClass::FOO).to eq(7)
-          end
-
-          it "can specify a list of nested constants to transfer" do
-            stub_const("MyGem::SomeClass", fake_class, :transfer_nested_constants => [:FOO])
-            expect(SomeClass::FOO).to eq(7)
-          end
-        end
-      end
-      """
-    When I run `rspec stub_const_spec.rb`
-    Then the examples should all pass

data/features/mutating_constants/stub_undefined_constant.feature

@@ -1,50 +0,0 @@
-Feature: Stub Undefined Constant
-
-  Use `stub_const` to stub constants. When the constant is not already defined,
-  all the necessary intermediary modules will be dynamically created. When the
-  example completes, the intermediary module constants will be removed to return
-  the constant state to how it started.
-
-  Scenario: Stub top-level constant
-    Given a file named "stub_const_spec.rb" with:
-      """ruby
-      describe "stubbing FOO" do
-        it "can stub undefined constant FOO" do
-          stub_const("FOO", 5)
-          expect(FOO).to eq(5)
-        end
-
-        it "undefines the constant when the example completes" do
-          expect { FOO }.to raise_error(NameError)
-        end
-      end
-      """
-    When I run `rspec stub_const_spec.rb`
-    Then the examples should all pass
-
-  Scenario: Stub nested constant
-    Given a file named "stub_const_spec.rb" with:
-      """ruby
-      module MyGem
-        class SomeClass
-        end
-      end
-
-      module MyGem
-        describe SomeClass do
-          it "can stub an arbitrarily deep constant that is undefined" do
-            expect(defined?(SomeClass::A)).to be_falsey
-            stub_const("MyGem::SomeClass::A::B::C", 3)
-            expect(SomeClass::A::B::C).to eq(3)
-            expect(SomeClass::A).to be_a(Module)
-          end
-
-          it 'undefines the intermediary constants that were dynamically created' do
-            expect(defined?(SomeClass)).to be_truthy
-            expect(defined?(SomeClass::A)).to be_falsey
-          end
-        end
-      end
-      """
-    When I run `rspec stub_const_spec.rb`
-    Then the examples should all pass

data/features/outside_rspec/standalone.feature

@@ -1,33 +0,0 @@
-Feature: standalone
-
-  require "rspec/mocks/standalone" to expose the mock framework
-  outside the RSpec environment. This is especially useful for
-  exploring rspec-mocks in irb.
-
-  Scenario: method stub 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: message expectation 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 the output should contain "RSpec::Mocks::MockExpectationError"
-    And the output should contain "say_hi(any args)"
-    And the output should contain "expected: 1 time"
-    And the output should contain "received: 0 times"

data/features/spies/spy_partial_mock_method.feature

@@ -1,34 +0,0 @@
-Feature: Spy on a stubbed method on a partial mock
-
-  You can also use `have_received` to verify that a stubbed method was invoked
-  on a partial mock.
-
-  Scenario: verify a stubbed method
-    Given a file named "verified_spy_spec.rb" with:
-      """ruby
-      describe "have_received" do
-        it "passes when the expectation is met" do
-          invitation = Object.new
-          invitation.stub(:deliver => true)
-          invitation.deliver
-          expect(invitation).to have_received(:deliver)
-        end
-      end
-      """
-    When I run `rspec verified_spy_spec.rb`
-    Then the examples should all pass
-
-  Scenario: fail to verify a stubbed method
-    Given a file named "failed_spy_spec.rb" with:
-      """ruby
-      describe "have_received" do
-        it "fails when the expectation is not met" do
-          invitation = Object.new
-          invitation.stub(:deliver => true)
-          expect(invitation).to have_received(:deliver)
-        end
-      end
-      """
-    When I run `rspec failed_spy_spec.rb`
-    Then the output should contain "expected: 1 time"
-     And the output should contain "received: 0 times"