rspec-mocks 2.11.3 → 3.11.1

data/features/README.md

@@ -1,67 +0,0 @@
-rspec-mocks helps to control the context in a code example by letting you set
-known return values, fake implementations of methods, and even expectations
-that specific messages are received by an object.
-
-You can do these three things on test doubles that rspec-mocks creates for you
-on the fly, or you can do them on objects that are part of your system.
-
-## Messages and Methods
-
-_Message_ and _method_ are metaphors that we use somewhat interchangeably, but
-they are subtly different.  In Object Oriented Programming, objects communicate
-by sending _messages_ to one another. When an object receives a message, it
-invokes a _method_ with the same name as the message.
-
-## Test Doubles
-
-A test double is an object that stands in for another object in your system
-during a code example. Use the `double` method to create one:
-
-    double_account = double("Account")
-
-You can also use the `mock` and `stub` methods to create test doubles, however
-these methods are there for backward compatibility only and will likely be
-deprecated and then removed from future versions.
-
-## Method Stubs
-
-A method stub is an instruction to an object (real or test double) to return a
-known value in response to a message:
-
-    die.stub(:roll) { 3 }
-
-This tells the `die` object to return the value `3` when it receives the `roll`
-message.
-
-## Message Expectations
-
-A message expectation is an expectation that an object should receive a
-specific message during the course of a code example:
-
-    describe Account do
-      context "when closed" do
-        it "logs an 'account closed' message" do
-          logger = double()
-          account = Account.new
-          account.logger = logger
-
-          logger.should_receive(:account_closed).with(account)
-
-          account.close
-        end
-      end
-    end
-
-This example specifies that the `account` object sends the `logger` the
-`account_closed` message (with itself as an argument) when it receives the
-`close` message.
-
-## Issues
-
-The documentation for rspec-mocks is a work in progress. We'll be adding
-Cucumber features over time, and clarifying existing ones.  If you have
-specific features you'd like to see added, find the existing documentation
-incomplete or confusing, or, better yet, wish to write a missing Cucumber
-feature yourself, please [submit an
-issue](http://github.com/rspec/rspec-mocks/issues) or a [pull
-request](http://github.com/rspec/rspec-mocks).

data/features/Scope.md

@@ -1,17 +0,0 @@
-Doubles, stubs, and message expectations are all cleaned out after each
-example. This ensures that each example can be run in isolation, and in any
-order.
-
-### `before(:each)`
-
-It is perfectly fine to set up doubles, stubs, and message expectations in
-a `before(:each)` hook, as that hook is executed in the scope of the example:
-
-    before(:each) do
-      @account = double('account')
-    end
-
-### Do not create doubles, stubs, or message expectations in `before(:all)`
-
-If you do, they'll get cleaned out after the first example, and you will be
-very confused as to what's going on in the second example.

data/features/Upgrade.md

@@ -1,22 +0,0 @@
-## rspec-mocks-2.6
-
-### `any_instance`
-
-Set method stubs and message expectations on any instance of a class:
-
-    class Foo; end
-    Foo.any_instance.stub(:bar) { 'bar' }
-    Foo.new.bar # => 'bar'
-
-## rspec-mocks-2.2
-
-### `require "rspec/mocks/standalone"`
-
-Sets up top-level environment to explore rspec-mocks. Mostly useful in irb:
-
-    $ irb
-    > require 'rspec/mocks/standalone'
-    > foo = double()
-    > foo.stub(:bar) { :baz }
-    > foo.bar
-      => :baz

data/features/argument_matchers/README.md

@@ -1,27 +0,0 @@
-### Introduction
-
-Argument matchers can be used:
-
-* In stubs to constrain the scope of the stubbed method
-
-    obj.stub(:foo).with(:bar) do |arg|
-      #do something for :bar
-    end
-    obj.stub(:foo).with(:baz) do |arg|
-      #do something for :baz
-    end
-
-* In expectations to validate the arguments that should be received in a method call
-
-    #create a double
-    obj = double()
-      
-    #expect a message with given args
-    obj.should_receive(:message).with('an argument')
-
-If more control is needed, one can use a block
-
-    obj.should_receive(:message) do |arg1,  arg2|
-      # set expectations about the args in this block
-      # and optionally set a return value
-    end

data/features/argument_matchers/explicit.feature

@@ -1,60 +0,0 @@
-Feature: explicit arguments
-
-  Allows you to explicitly specify the argument values
-
-  Scenario: explicit arguments
-    Given a file named "stub_explicit_args_spec.rb" with:
-      """
-      describe "stubbed explicit arguments" do
-        it "works on stubs" do
-          object = Object.new
-          object.stub(:foo).with(:this) do |arg|
-            "got this"
-          end
-          object.stub(:foo).with(:that) do |arg|
-            "got that"
-          end
-
-          object.foo(:this).should eq("got this")
-          object.foo(:that).should eq("got that")
-        end
-
-        it "works on doubles and expectations" do
-          object = double('foo')
-          object.should_receive(:bar).with(:foo)
-
-          object.bar(:foo)
-        end
-      end
-      """
-    When I run `rspec stub_explicit_args_spec.rb`
-    Then the output should contain "2 examples, 0 failures"
-
-  Scenario: explicit arguments with multiple arities
-    Given a file named "stub_multiple_explicit_args_spec.rb" with:
-      """
-      describe "stubbed multiple explicit arguments" do
-        it "works on stubs" do
-          object = Object.new
-          object.stub(:foo).with(:this) do |arg|
-            "got this"
-          end
-          object.stub(:foo).with(:this, :that) do |arg1, arg2|
-            "got this and that"
-          end
-
-          object.foo(:this).should eq("got this")
-          object.foo(:this, :that).should eq("got this and that")
-        end
-        
-        it "works on mocks" do
-          object = double('foo')
-          object.should_receive(:foo).with(:this, :that)
-
-          object.foo(:this, :that)
-        end
-      end
-      """
-    When I run `rspec stub_multiple_explicit_args_spec.rb`
-    Then the output should contain "2 examples, 0 failures"
-

data/features/argument_matchers/general_matchers.feature

@@ -1,85 +0,0 @@
-Feature: General matchers
-
-  The `anything`,  `any_args`,  and `no_args` matchers can be used to require the method 
-  to have arguments (or not) without constraining the details of the argument, such as its
-  type,  pattern or value. The `anything` matcher only reflects a single argument, while
-  the `any_args` matcher matches any arity.
-
-  Scenario: anything argument matcher
-    Given a file named "stub_anything_args_spec.rb" with:
-      """
-      describe "stubbed anything() args spec" do
-        it "works" do
-          object = Object.new
-          object.stub(:foo).with(anything) do
-            "anything"
-          end
-
-          object.foo(1).should eq("anything")
-          object.foo(:that).should eq("anything")
-        end
-      end
-      """
-    When I run `rspec stub_anything_args_spec.rb`
-    Then the output should contain "1 example, 0 failures"
-
-  Scenario: any_args argument matcher
-    Given a file named "stub_any_args_spec.rb" with:
-      """
-      describe "stubbed any_args() args spec" do
-        it "works" do
-          object = Object.new
-          object.stub(:foo).with(any_args) do
-            "anything"
-          end
-
-          object.foo(1).should eq("anything")
-          object.foo(:that).should eq("anything")
-          object.foo.should eq("anything")
-        end
-      end
-      """
-    When I run `rspec stub_any_args_spec.rb`
-    Then the output should contain "1 example, 0 failures"
-
-  Scenario: no_args argument matcher
-    Given a file named "stub_no_args_spec.rb" with:
-      """
-      describe "stubbed no_args() args spec" do
-        it "works for no args" do
-          object = Object.new
-          object.stub(:foo).with(no_args) do
-            "nothing"
-          end
-          object.stub(:foo).with(anything) do
-            "something"
-          end
-
-          object.foo(:that).should eq("something")
-          object.foo.should eq("nothing")
-        end
-      end
-      """
-    When I run `rspec stub_no_args_spec.rb`
-    Then the output should contain "1 example, 0 failures"
-
-  Scenario: no_args argument matcher for expectations
-    Given a file named "stub_no_args_expectations_spec.rb" with:
-      """
-      describe "stubbed no_args() args spec for expectations" do
-        it "works for no args" do
-          object = Object.new
-          object.should_receive(:foo).with(no_args)
-
-          object.foo
-        end
-        it "fails for args" do
-          object = Object.new
-          object.should_receive(:foo).with(no_args)
-
-          object.foo(:bar)
-        end
-      end
-      """
-    When I run `rspec stub_no_args_expectations_spec.rb`
-    Then the output should contain "2 examples, 1 failure"

data/features/argument_matchers/type_matchers.feature

@@ -1,27 +0,0 @@
-Feature: stub with argument constraints
-
-  You can further specify the behavior by constraining the type,
-  format and/or number of arguments with the `#with()` method 
-  chained off of `#stub()`
-  
-  Scenario: an_instance_of argument matcher
-    Given a file named "stub_an_instance_of_args_spec.rb" with:
-      """
-      describe "stubbed an_instance_of() args spec" do
-        it "works" do
-          object = Object.new
-          object.stub(:foo).with(an_instance_of(Symbol)) do
-            "symbol"
-          end
-          object.stub(:foo).with(an_instance_of(String)) do
-            "string"
-          end
-
-          object.foo("bar").should eq("string")
-          object.foo(:that).should eq("symbol")
-        end
-      end
-      """
-    When I run `rspec stub_an_instance_of_args_spec.rb`
-    Then the output should contain "1 example, 0 failures"
-

data/features/message_expectations/README.md

@@ -1,69 +0,0 @@
-### Basics
-
-    # create a double
-    obj = double()
-
-    # expect a message
-    obj.should_receive(:message)
-
-    # specify a return value
-    obj.should_receive(:message) { :value }
-    obj.should_receive(:message => :value)
-    obj.should_receive(:message).and_return(:value)
-
-These forms are somewhat interchangeable. The difference is that the
-block contents are evaluated lazily when the `obj` receives the
-`message` message, whereas the others are evaluated as they are read.
-
-### Fake implementation
-
-    obj.should_receive(:message) do |arg1, arg2|
-      # set expectations about the args in this block
-      # and set a return value
-    end
-
-### Raising/Throwing
-
-    obj.should_receive(:message).and_raise("this error")
-    obj.should_receive(:message).and_throw(:this_symbol)
-
-You can also use the block format:
-
-    obj.should_receive(:message) { raise "this error" }
-    obj.should_receive(:message) { throw :this_symbol }
-
-### Argument constraints
-   
-#### Explicit arguments
-
-    obj.should_receive(:message).with('an argument')
-    obj.should_receive(:message).with('more_than', 'one_argument')
-
-#### Argument matchers
-
-    obj.should_receive(:message).with(anything())
-    obj.should_receive(:message).with(an_instance_of(Money))
-    obj.should_receive(:message).with(hash_including(:a => 'b'))
-
-#### Regular expressions
-
-    obj.should_receive(:message).with(/abc/)
-
-### Counts 
-
-    obj.should_receive(:message).once
-    obj.should_receive(:message).twice
-    obj.should_receive(:message).exactly(3).times
-
-    obj.should_receive(:message).at_least(:once)
-    obj.should_receive(:message).at_least(:twice)
-    obj.should_receive(:message).at_least(n).times
-
-    obj.should_receive(:message).at_most(:once)
-    obj.should_receive(:message).at_most(:twice)
-    obj.should_receive(:message).at_most(n).times
-
-### Ordering
-
-    obj.should_receive(:one).ordered
-    obj.should_receive(:two).ordered

data/features/message_expectations/any_instance.feature

@@ -1,21 +0,0 @@
-Feature: expect a message on any instance of a class
-
-  Use `any_instance.should_receive` to set an expectation that one (and only
-  one) instance of a class receives a message before the example is completed.
-  
-  The spec will fail if no instance receives a message.
-
-  Scenario: expect a message on any instance of a class
-    Given a file named "example_spec.rb" with:
-      """
-      describe "any_instance.should_receive" do
-        it "verifies that one instance of the class receives the message" do
-          Object.any_instance.should_receive(:foo).and_return(:return_value)
-
-          o = Object.new
-          o.foo.should eq(:return_value)
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the examples should all pass

data/features/message_expectations/block_local_expectations.feature.pending

@@ -1,55 +0,0 @@
-Feature: block local expectations
-
-  Background:
-    Given a file named "lib/account.rb" with:
-      """
-      class Account
-        def self.create
-          yield new
-        end
-
-        def opening_balance(amount, currency)
-        end
-      end
-      """
-
-  Scenario: passing example
-    Given a file named "spec/account_spec.rb" with:
-      """
-      require 'account'
-
-      describe "account DSL" do
-        it "it succeeds when the block local receives the given call" do
-          account = double("Account")
-          Account.should_receive(:create).and_yield(account) do |account|
-            account.should_receive(:opening_balance).with(100, :USD)
-          end
-          Account.create do |account|
-            account.opening_balance 100, :USD
-          end
-        end
-      end
-      """
-    When I run `rspec spec/account_spec.rb`
-    Then the output should contain "1 example, 0 failures"
-    
-  Scenario: failing example
-    
-    Given a file named "spec/account_spec.rb" with:
-      """
-      require 'account'
-
-      describe "account DSL" do
-        it "fails when the block local does not receive the expected call" do
-          Account.should_receive(:create).and_yield do |account|
-            account.should_receive(:opening_balance).with(100, :USD)
-          end
-          Account.create do |account|
-            # opening_balance is not called here
-          end
-        end
-      end
-      """
-
-    When I run `rspec spec/account_spec.rb`
-    Then the output should contain "1 example, 1 failure"

data/features/message_expectations/expect_message.feature

@@ -1,94 +0,0 @@
-Feature: expect a message
-
-  Use should_receive() to set an expectation that a receiver should receive a
-  message before the example is completed.
-
-  Scenario: expect a message
-    Given a file named "spec/account_spec.rb" with:
-      """
-      require "account"
-
-      describe Account do
-        context "when closed" do
-          it "logs an account closed message" do
-            logger = double("logger")
-            account = Account.new
-            account.logger = logger
-
-            logger.should_receive(:account_closed)
-
-            account.close
-          end
-        end
-      end
-      """
-    And a file named "lib/account.rb" with:
-      """
-      class Account
-        attr_accessor :logger
-
-        def close
-          logger.account_closed
-        end
-      end
-      """
-    When I run `rspec spec/account_spec.rb`
-    Then the output should contain "1 example, 0 failures"
-
-  Scenario: expect a message with an argument
-    Given a file named "spec/account_spec.rb" with:
-      """
-      require "account"
-
-      describe Account do
-        context "when closed" do
-          it "logs an account closed message" do
-            logger = double("logger")
-            account = Account.new
-            account.logger = logger
-
-            logger.should_receive(:account_closed).with(account)
-
-            account.close
-          end
-        end
-      end
-      """
-    And a file named "lib/account.rb" with:
-      """
-      class Account
-        attr_accessor :logger
-
-        def close
-          logger.account_closed(self)
-        end
-      end
-      """
-    When I run `rspec spec/account_spec.rb`
-    Then the output should contain "1 example, 0 failures"
-
-  Scenario: provide a return value
-    Given a file named "message_expectation_spec.rb" with:
-      """
-      describe "a message expectation" do
-        context "with a return value" do
-          context "specified in a block" do
-            it "returns the specified value" do
-              receiver = double("receiver")
-              receiver.should_receive(:message) { :return_value }
-              receiver.message.should eq(:return_value)
-            end
-          end
-
-          context "specified with and_return" do
-            it "returns the specified value" do
-              receiver = double("receiver")
-              receiver.should_receive(:message).and_return(:return_value)
-              receiver.message.should eq(:return_value)
-            end
-          end
-        end
-      end
-      """
-    When I run `rspec message_expectation_spec.rb`
-    Then the output should contain "2 examples, 0 failures"