rspec-mocks 2.5.0 → 2.6.0.rc2

data/.travis.yml

@@ -0,0 +1,7 @@
+script: "rake"
+rvm:
+  - 1.8.6
+  - 1.8.7
+  - 1.9.1
+  - 1.9.2
+  - ree

data/Gemfile

@@ -6,29 +6,31 @@ source "http://rubygems.org"
   if File.exist?(library_path)
     gem lib, :path => library_path
   else
-    gem lib
+    gem lib, :git => "git://github.com/rspec/#{lib}.git"
   end
 end
 
 ### dev dependencies
 gem "rake", "0.8.7"
-gem "cucumber", "0.9.4"
-gem "aruba", "0.2.2"
-gem "rcov", "0.9.9"
+# gem "cucumber", "~> 0.10.2"
+# gem "aruba", :git => "git://github.com/aslakhellesoy/aruba"
+gem "rcov", "0.9.9", :platforms => :mri
 gem "relish", "0.2.0"
 gem "guard-rspec", "0.1.9"
 gem "growl", "1.0.3"
-gem "ZenTest", "~> 4.4.2"
+gem "nokogiri", "1.4.4"
 
-if RUBY_PLATFORM =~ /darwin/
-  gem "autotest-fsevent", "~> 0.2.4"
-  gem "autotest-growl", "~> 0.2.9"
+platforms :mri_18 do
+  gem 'ruby-debug'
 end
 
-gem "ruby-debug", :platforms => :ruby_18
-gem "ruby-debug19", "~> 0.11.6", :platforms => :ruby_19
+platforms :mri_19 do
+  gem 'linecache19', '0.5.11' # 0.5.12 cannot install on 1.9.1, and 0.5.11 appears to work with both 1.9.1 & 1.9.2
+  gem 'ruby-debug19'
+  gem 'ruby-debug-base19', RUBY_VERSION == '1.9.1' ? '0.11.23' : '~> 0.11.24'
+end
 
-platforms :ruby_18, :ruby_19 do
+platforms :mri_18, :mri_19 do
   gem "rb-fsevent", "~> 0.3.9"
   gem "ruby-prof", "~> 0.9.2"
 end
@@ -36,4 +38,3 @@ end
 platforms :jruby do
   gem "jruby-openssl"
 end
-

data/Guardfile

@@ -2,7 +2,7 @@
 # More info at http://github.com/guard/guard#readme
 
 guard 'rspec', :version => 2 do
-  watch('^spec/(.*)_spec.rb')
-  watch('^lib/(.*)\.rb')                              { "spec" }
-  watch('^spec/spec_helper.rb')                       { "spec" }
+  watch(/^spec\/(.*)_spec.rb/)
+  watch(/^lib\/(.*)\.rb/)                              { "spec" }
+  watch(/^spec\/spec_helper.rb/)                       { "spec" }
 end

data/README.md

@@ -3,6 +3,8 @@
 rspec-mocks provides a test-double framework for rspec including support
 for method stubs, fakes, and message expectations.
 
+[![build status](http://travis-ci.org/rspec/rspec-mocks.png)](http://travis-ci.org/rspec/rspec-mocks)
+
 ## Documentation
 
 The [Cucumber features](http://relishapp.com/rspec/rspec-mocks) are the

data/features/.nav

@@ -4,8 +4,12 @@
   - simple_return_value.feature
   - stub_implementation.feature
   - stub_chain.feature
+  - any_instance.feature
+  - as_null_object.feature
+  - to_ary.feature
 - message_expectations:
   - expect_message.feature
+  - any_instance.feature
   - block_local_expectations.feature.pending
   - warn_when_expectation_is_set_on_nil.feature
 - outside_rspec:

data/features/Changelog.md

@@ -1,3 +1,15 @@
+### 2.6.0.rc2 / 2011-04-18
+
+[full changelog](http://github.com/rspec/rspec-mocks/compare/v2.5.0...v2.6.1.rc2)
+
+* Enhancements
+  * Add support for any_instance.stub and any_instance.should_receive (Sidu
+    Ponnappa and Andy Lindeman)
+
+* Bug fixes
+  * fix bug in which multiple chains with shared messages ending in hashes
+    failed to return the correct value
+
 ### 2.5.0 / 2011-02-05
 
 [full changelog](http://github.com/rspec/rspec-mocks/compare/v2.4.0...v2.5.0)

data/features/README.markdown

@@ -1,10 +1,46 @@
-rspec-mocks is used to create dynamic "doubles", which stand in for real
-objects in examples. You can stub return values and/or set message
-expectations:
+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
+        it "logs an 'account closed' message" do
           logger = double()
           account = Account.new
           account.logger = logger
@@ -16,6 +52,10 @@ expectations:
       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

data/features/message_expectations/any_instance.feature

@@ -0,0 +1,19 @@
+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.
+
+  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

@@ -30,7 +30,7 @@ Feature: block local expectations
         end
       end
       """
-    When I run "rspec ./spec/account_spec.rb"
+    When I run `rspec spec/account_spec.rb`
     Then the output should contain "1 example, 0 failures"
     
   Scenario: failing example
@@ -51,5 +51,5 @@ Feature: block local expectations
       end
       """
 
-    When I run "rspec ./spec/account_spec.rb"
+    When I run `rspec spec/account_spec.rb`
     Then the output should contain "1 example, 1 failure"

data/features/message_expectations/expect_message.feature

@@ -32,7 +32,7 @@ Feature: expect a message
         end
       end
       """
-    When I run "rspec spec/account_spec.rb"
+    When I run `rspec spec/account_spec.rb`
     Then the output should contain "1 example, 0 failures"
 
   Scenario: expect a message with an argument
@@ -64,7 +64,7 @@ Feature: expect a message
         end
       end
       """
-    When I run "rspec spec/account_spec.rb"
+    When I run `rspec spec/account_spec.rb`
     Then the output should contain "1 example, 0 failures"
 
   Scenario: provide a return value
@@ -90,5 +90,5 @@ Feature: expect a message
         end
       end
       """
-    When I run "rspec message_expectation_spec.rb"
+    When I run `rspec message_expectation_spec.rb`
     Then the output should contain "2 examples, 0 failures"

data/features/message_expectations/warn_when_expectation_is_set_on_nil.feature

@@ -11,7 +11,7 @@ Feature: warn when expectation is set on nil
         end
       end
       """
-    When I run "rspec ./example_spec.rb"
+    When I run `rspec example_spec.rb`
     Then the output should contain "An expectation of :foo was set on nil"
 
   Scenario: allow
@@ -26,7 +26,7 @@ Feature: warn when expectation is set on nil
         end
       end
       """
-    When I run "rspec ./example_spec.rb"
+    When I run `rspec example_spec.rb`
     Then the output should not contain "An expectation"
 
   Scenario: allow in one example, but not on another
@@ -45,6 +45,6 @@ Feature: warn when expectation is set on nil
         end
       end
       """
-    When I run "rspec ./example_spec.rb"
+    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,39 +1,47 @@
-### Basics
+### Stub return values
 
-    # create a double
-    obj = double()
+    obj.stub(:message).and_return('this is the value to return')
+    obj.stub(:message) { 'this is the value to return' }
 
-    # stub a method
-    obj.stub(:message) # returns obj
+These two forms are somewhat interchangeable. The difference is that the
+argument to `and_return` is evaluated immediately, whereas the block contents
+are evaluated lazily when the `obj` receives the `message` message.
 
-    # specify a return value
-    obj.stub(:message) { 'this is the value to return' }
+The block format is generally preferred as it is more terse and more consistent
+with other forms described below, but lazy evaluation can be confusing because
+things aren't evaluated in the order in which they are declared.
+
+### 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, for consistency with other stubs:
+
+    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')
+    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'))
+    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/)
-
-### Raising/Throwing
+    obj.stub(:message).with(/abc/) { ... }
 
-    obj.stub(:message) { raise "this error" }
-    obj.stub(:message) { throw :this_symbol }
-
-### Arbitrary handling
-
-    obj.stub(:message) do |arg1, arg2|
-      # set expectations about the args in this block
-      # and set a return value
-    end

data/features/method_stubs/any_instance.feature

@@ -0,0 +1,23 @@
+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: simple 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
+

data/features/method_stubs/as_null_object.feature

@@ -0,0 +1,36 @@
+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 = double('foo')
+          [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

@@ -20,7 +20,7 @@ Feature: stub with a simple return value
         end
       end
       """
-    When I run "rspec example_spec.rb"
+    When I run `rspec example_spec.rb`
     Then the output should contain "0 failures"
 
   Scenario: single return value
@@ -51,5 +51,5 @@ Feature: stub with a simple return value
         end
       end
       """
-    When I run "rspec example_spec.rb"
+    When I run `rspec example_spec.rb`
     Then the output should contain "0 failures"

data/features/method_stubs/stub_chain.feature

@@ -1,9 +1,9 @@
 Feature: stub a chain of methods
 
-  The `stub_chain` method lets you to stub a chain of methods in one statement.
-  Method chains are considered a design smell, but it's not really the method
-  chain that is the problem - it's the dependency chain represented by a chain
-  of messages to different objects:
+  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
 
@@ -32,6 +32,13 @@ Feature: stub a chain of methods
           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)
@@ -40,5 +47,5 @@ Feature: stub a chain of methods
         end
       end
       """
-    When I run "rspec stub_chain_spec.rb"
-    Then the output should contain "2 examples, 0 failures"
+    When I run `rspec stub_chain_spec.rb`
+    Then the examples should all pass

data/features/method_stubs/stub_implementation.feature

@@ -22,5 +22,5 @@ Feature: stub with substitute implementation
         end
       end
       """
-    When I run "rspec ./stub_implementation_spec.rb"
+    When I run `rspec stub_implementation_spec.rb`
     Then the output should contain "1 example, 0 failures"