rspec-mocks 2.11.3 → 3.11.1

data/features/message_expectations/receive_counts.feature

@@ -1,209 +0,0 @@
-Feature: receive counts
-
-  Scenario: expect a message once
-    Given a file named "spec/account_spec.rb" with:
-      """
-      class Account
-        attr_accessor :logger
-
-        def open
-          logger.account_opened
-        end
-      end
-
-      describe Account do
-        context "when opened" do
-          it "logger#account_opened was called once" do
-            logger = double("logger")
-            account = Account.new
-            account.logger = logger
-
-            logger.should_receive(:account_opened).once
-
-            account.open
-          end
-        end
-      end
-      """
-    When I run `rspec spec/account_spec.rb`
-    Then the output should contain "1 example, 0 failures"
-
-  Scenario: expect a message twice
-    Given a file named "spec/account_spec.rb" with:
-      """
-      class Account
-        attr_accessor :logger
-
-        def open
-          logger.account_opened
-        end
-      end
-
-      describe Account do
-        context "when opened" do
-          it "logger#account_opened was called once" do
-            logger = double("logger")
-            account = Account.new
-            account.logger = logger
-
-            logger.should_receive(:account_opened).twice
-
-            account.open
-            account.open
-          end
-        end
-      end
-      """
-    When I run `rspec spec/account_spec.rb`
-    Then the output should contain "1 example, 0 failures"
-
-  Scenario: expect a message 3 times
-    Given a file named "spec/account_spec.rb" with:
-      """
-      class Account
-        attr_accessor :logger
-
-        def open
-          logger.account_opened
-        end
-      end
-
-      describe Account do
-        context "when opened" do
-          it "logger#account_opened was called once" do
-            logger = double("logger")
-            account = Account.new
-            account.logger = logger
-
-            logger.should_receive(:account_opened).exactly(3).times
-
-            account.open
-            account.open
-            account.open
-          end
-        end
-      end
-      """
-    When I run `rspec spec/account_spec.rb`
-    Then the output should contain "1 example, 0 failures"
-
-  Scenario: expect a message at least (:once)
-    Given a file named "spec/account_spec.rb" with:
-      """
-      class Account
-        attr_accessor :logger
-
-        def open
-          logger.account_opened
-        end
-      end
-
-      describe Account do
-        context "when opened" do
-          it "logger#account_opened was called once" do
-            logger = double("logger")
-            account = Account.new
-            account.logger = logger
-
-            logger.should_receive(:account_opened).at_least(:once)
-
-            account.open
-          end
-        end
-      end
-      """
-    When I run `rspec spec/account_spec.rb`
-    Then the output should contain "1 example, 0 failures"
-
-
-  Scenario: expect a message at least (n) times
-    Given a file named "spec/account_spec.rb" with:
-      """
-      class Account
-        attr_accessor :logger
-
-        def open
-          logger.account_opened
-        end
-      end
-
-      describe Account do
-        context "when opened" do
-          it "logger#account_opened was called once" do
-            logger = double("logger")
-            account = Account.new
-            account.logger = logger
-
-            logger.should_receive(:account_opened).at_least(3).times
-
-            # Note that I am calling method under test 4 times
-            # and I specified it to be called at least 3 times
-            account.open
-            account.open
-            account.open
-            account.open
-          end
-        end
-      end
-      """
-    When I run `rspec spec/account_spec.rb`
-    Then the output should contain "1 example, 0 failures"
-
-  Scenario: expect a message at most (:once)
-    Given a file named "spec/account_spec.rb" with:
-      """
-      class Account
-        attr_accessor :logger
-
-        def open
-          logger.account_opened
-        end
-      end
-
-      describe Account do
-        context "when opened" do
-          it "logger#account_opened was called once" do
-            logger = double("logger")
-            account = Account.new
-            account.logger = logger
-
-            logger.should_receive(:account_opened).at_most(:once)
-
-            account.open
-            account.open
-          end
-        end
-      end
-      """
-    When I run `rspec spec/account_spec.rb`
-    Then the output should contain "expected: 1 time"
-     And the output should contain "received: 2 times"
-
-  Scenario: expect a message at most (n) times
-    Given a file named "spec/account_spec.rb" with:
-      """
-      class Account
-        attr_accessor :logger
-
-        def open
-          logger.account_opened
-        end
-      end
-
-      describe Account do
-        context "when opened" do
-          it "logger#account_opened was called once" do
-            logger = double("logger")
-            account = Account.new
-            account.logger = logger
-
-            logger.should_receive(:account_opened).at_most(2).times
-
-            account.open
-            account.open
-          end
-        end
-      end
-      """
-    When I run `rspec spec/account_spec.rb`
-    Then the output should contain "1 example, 0 failures"

data/features/message_expectations/warn_when_expectation_is_set_on_nil.feature

@@ -1,50 +0,0 @@
-Feature: warn when expectation is set on nil
-
-  Scenario: nil instance variable
-    Given a file named "example_spec.rb" with:
-      """
-      RSpec.configure {|c| c.mock_with :rspec}
-      describe "something" do
-        it "does something" do
-          @i_do_not_exist.should_receive(:foo)
-          @i_do_not_exist.foo
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the output should contain "An expectation of :foo was set on nil"
-
-  Scenario: allow
-    Given a file named "example_spec.rb" with:
-      """
-      RSpec.configure {|c| c.mock_with :rspec}
-      describe "something" do
-        it "does something" do
-          allow_message_expectations_on_nil
-          nil.should_receive(:foo)
-          nil.foo
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the output should not contain "An expectation"
-
-  Scenario: allow in one example, but not on another
-    Given a file named "example_spec.rb" with:
-      """
-      RSpec.configure {|c| c.mock_with :rspec}
-      describe "something" do
-        it "does something (foo)" do
-          allow_message_expectations_on_nil
-          nil.should_receive(:foo)
-          nil.foo
-        end
-        it "does something (bar)" do
-          nil.should_receive(:bar)
-          nil.bar
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the output should contain "An expectation of :bar"
-    And  the output should not contain "An expectation of :foo"

data/features/method_stubs/README.md

@@ -1,47 +0,0 @@
-### Stub return values
-
-    # create a double
-    obj = double()
-
-    # specify a return value
-    obj.stub(:message) { :value }
-    obj.stub(:message => :value)
-    obj.stub(: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.stub(:message) do |arg1, arg2|
-      # set expectations about the args in this block
-      # and/or set a return value
-    end
-
-### Raising/Throwing
-
-    obj.stub(:message).and_raise("this error")
-    obj.stub(:message).and_throw(:this_symbol)
-
-You can also use the block format:
-
-    obj.stub(:message) { raise "this error" }
-    obj.stub(:message) { throw :this_symbol }
-
-### Argument constraints
-   
-#### Explicit arguments
-
-    obj.stub(:message).with('an argument') { ... }
-    obj.stub(:message).with('more_than', 'one_argument') { ... }
-
-#### Argument matchers
-
-    obj.stub(:message).with(anything()) { ... }
-    obj.stub(:message).with(an_instance_of(Money)) { ... }
-    obj.stub(:message).with(hash_including(:a => 'b')) { ... }
-
-#### Regular expressions
-
-    obj.stub(:message).with(/abc/) { ... }

data/features/method_stubs/any_instance.feature

@@ -1,133 +0,0 @@
-Feature: stub on any instance of a class
-
-  Use `any_instance.stub` on a class to tell any instance of that class to
-  return a value (or values) in response to a given message.  If no instance
-  receives the message, nothing happens.
-
-  Messages can be stubbed on any class, including those in Ruby's core library.
-
-  Scenario: any_instance stub with a single return value
-    Given a file named "example_spec.rb" with:
-      """
-      describe "any_instance.stub" do
-        it "returns the specified value on any instance of the class" do
-          Object.any_instance.stub(: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
-    
-  Scenario: any_instance stub with a hash
-    Given a file named "example_spec.rb" with:
-      """
-      describe "any_instance.stub" do
-        context "with a hash" do
-          it "returns the hash values on any instance of the class" do
-            Object.any_instance.stub(:foo => 'foo', :bar => 'bar')
-
-            o = Object.new
-            o.foo.should eq('foo')
-            o.bar.should eq('bar')
-          end
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the examples should all pass  
-    
-  Scenario: any_instance stub with specific arguments matchers
-    Given a file named "example_spec.rb" with:
-      """
-      describe "any_instance.stub" do
-        context "with arguments" do
-          it "returns the stubbed value when arguments match" do
-            Object.any_instance.stub(:foo).with(:param_one, :param_two).and_return(:result_one)
-            Object.any_instance.stub(:foo).with(:param_three, :param_four).and_return(:result_two)
-          
-            o = Object.new
-            o.foo(:param_one, :param_two).should eq(:result_one)
-            o.foo(:param_three, :param_four).should eq(:result_two)
-          end
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the examples should all pass
-  
-  Scenario: any_instance unstub
-    Given a file named "example_spec.rb" with:
-      """
-      describe "any_instance.unstub" do
-        it "unstubs a stubbed method" do
-          class Object
-            def foo
-              :foo
-            end
-          end
-          
-          Object.any_instance.stub(:foo)
-          Object.any_instance.unstub(:foo)
-
-          Object.new.foo.should eq(:foo)
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the examples should all pass  
-  
-  Scenario: any_instance unstub
-    Given a file named "example_spec.rb" with:
-      """
-      describe "any_instance.unstub" do
-        context "with both an expectation and a stub already set" do
-          it "only removes the stub" do
-            class Object
-              def foo
-                :foo
-              end
-            end
-            Object.any_instance.should_receive(:foo).and_return(:bar)
-            Object.any_instance.stub(:foo)
-            Object.any_instance.unstub(:foo)
-            
-            Object.new.foo.should eq(:bar)
-          end
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the examples should all pass
-    
-  Scenario: stub a chain of methods an any instance
-    Given a file named "stub_chain_spec.rb" with:
-      """
-      describe "stubbing a chain of methods" do
-        context "given symbols representing methods" do
-          it "returns the correct value" do
-            Object.any_instance.stub_chain(:one, :two, :three).and_return(:four)
-            Object.new.one.two.three.should eq(:four)
-          end
-        end
-
-        context "given a hash at the end" do
-          it "returns the correct value" do
-            Object.any_instance.stub_chain(:one, :two, :three => :four)
-            Object.new.one.two.three.should eq(:four)
-          end
-        end
-
-        context "given a string of methods separated by dots" do
-          it "returns the correct value" do
-            Object.any_instance.stub_chain("one.two.three").and_return(:four)
-            Object.new.one.two.three.should eq(:four)
-          end
-        end
-      end
-      """
-    When I run `rspec stub_chain_spec.rb`
-    Then the examples should all pass
-    

data/features/method_stubs/as_null_object.feature

@@ -1,35 +0,0 @@
-Feature: as_null_object
-
-  Use the `as_null_object` method to ignore any messages that aren't explicitly
-  set as stubs or message expectations.
-
-  EXCEPTION: `to_ary` will raise a NoMethodError unless explicitly stubbed in
-  order to support `flatten` on an Array containing a double.
-
-  Scenario: double acting as_null_object 
-    Given a file named "as_null_object_spec.rb" with:
-      """
-      describe "a double with as_null_object called" do
-        let(:null_object) { double('null object').as_null_object }
-
-        it "responds to any method that is not defined" do
-          null_object.should respond_to(:an_undefined_method)
-        end
-
-        it "allows explicit stubs" do
-          null_object.stub(:foo) { "bar" }
-          null_object.foo.should eq("bar")
-        end
-
-        it "allows explicit expectations" do
-          null_object.should_receive(:something)
-          null_object.something
-        end
-
-        it "supports Array#flatten" do
-          [null_object].flatten.should eq([null_object])
-        end
-      end
-      """
-    When I run `rspec as_null_object_spec.rb`
-    Then the examples should all pass

data/features/method_stubs/simple_return_value.feature

@@ -1,64 +0,0 @@
-Feature: stub with a simple return value
-
-  Use the `stub` method on a test double or a real object to tell the object to
-  return a value (or values) in response to a given message. Nothing happens if
-  the message is never received.
-
-  Scenario: stub with no return value
-    Given a file named "example_spec.rb" with:
-      """
-      describe "a stub with no return value specified" do
-        let(:collaborator) { double("collaborator") }
-
-        it "returns nil" do
-          collaborator.stub(:message)
-          collaborator.message.should be(nil)
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the examples should all pass
-
-  Scenario: stubs with return values
-    Given a file named "example_spec.rb" with:
-      """
-      describe "a stub with a return value" do
-        context "specified in a block" do
-          it "returns the specified value" do
-            collaborator = double("collaborator")
-            collaborator.stub(:message) { :value }
-            collaborator.message.should eq(:value)
-          end
-        end
-
-        context "specified with #and_return" do
-          it "returns the specified value" do
-            collaborator = double("collaborator")
-            collaborator.stub(:message).and_return(:value)
-            collaborator.message.should eq(:value)
-          end
-        end
-
-        context "specified with a hash passed to #stub" do
-          it "returns the specified value" do
-            collaborator = double("collaborator")
-            collaborator.stub(:message_1 => :value_1, :message_2 => :value_2)
-            collaborator.message_1.should eq(:value_1)
-            collaborator.message_2.should eq(:value_2)
-          end
-        end
-
-        context "specified with a hash passed to #double" do
-          it "returns the specified value" do
-            collaborator = double("collaborator",
-              :message_1 => :value_1,
-              :message_2 => :value_2
-            )
-            collaborator.message_1.should eq(:value_1)
-            collaborator.message_2.should eq(:value_2)
-          end
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the examples should all pass

data/features/method_stubs/stub_chain.feature

@@ -1,51 +0,0 @@
-Feature: stub a chain of methods
-
-  Use the `stub_chain` method to stub a chain of two or more methods in one
-  statement.  Method chains are considered a design smell, but it's not really
-  the method chain itself that is the problem - it's the dependency chain
-  represented by a chain of messages to different objects:
-
-      foo.get_bar.get_baz
-
-  This is a Law of Demeter violation if `get_bar` returns an object other than
-  `foo`, and `get_baz` returns yet another object.
-
-  Fluent interfaces look similar from a caller's perspective, but don't
-  represent a dependency chain (the caller depends only on the object it is
-  calling). Consider this common example from Ruby on Rails:
-
-      Article.recent.by(current_user)
-
-  The `recent` and `by` methods return the same object, so this is not a Law of
-  Demeter violation.
-
-  Scenario: stub a chain of methods
-    Given a file named "stub_chain_spec.rb" with:
-      """
-      describe "stubbing a chain of methods" do
-        subject { Object.new }
-
-        context "given symbols representing methods" do
-          it "returns the correct value" do
-            subject.stub_chain(:one, :two, :three).and_return(:four)
-            subject.one.two.three.should eq(:four)
-          end
-        end
-
-        context "given a hash at the end" do
-          it "returns the correct value" do
-            subject.stub_chain(:one, :two, :three => :four)
-            subject.one.two.three.should eq(:four)
-          end
-        end
-
-        context "given a string of methods separated by dots" do
-          it "returns the correct value" do
-            subject.stub_chain("one.two.three").and_return(:four)
-            subject.one.two.three.should eq(:four)
-          end
-        end
-      end
-      """
-    When I run `rspec stub_chain_spec.rb`
-    Then the examples should all pass

data/features/method_stubs/stub_implementation.feature

@@ -1,26 +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
-    Given a file named "stub_implementation_spec.rb" with:
-      """
-      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
-          
-          object.foo(:this).should eq("got this")
-          object.foo(:that).should 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,47 +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:
-      """
-      describe "#to_ary" do
-        shared_examples "to_ary" do
-          it "raises a NoMethodError" do
-            expect { obj.to_ary }.to raise_error(NoMethodError)
-          end
-
-          it "can be overridden with a stub" do
-            obj.stub(:to_ary) { :non_nil_value }
-            obj.to_ary.should be(:non_nil_value)
-          end
-
-          it "supports Array#flatten" do
-            obj = double('foo')
-            [obj].flatten.should eq([obj])
-          end
-        end
-
-        context "sent to a double as_null_object" do
-          let(:obj) { double('obj').as_null_object }
-          include_examples "to_ary"
-        end
-
-        context "sent to a double without as_null_object" do
-          let(:obj) { double('obj') }
-          include_examples "to_ary"
-        end
-      end
-     """
-    When I run `rspec example.rb`
-    Then the examples should all pass