rspec-mocks 3.0.0.beta1 → 3.0.0.beta2

data.tar.gz.sig

@@ -1 +1 @@
-�旺]v�����h��(*�z(��������:�d-XH�?ibI�4L��0*�ʆ˫K��Y?D��u<��);�p��]8�ҥ��P��8�ۥ��v<�MZ�M@���3��ӑ۶�Y���Ͷ�D�ОP	�Mɭ�(B�[�Vk�"8��)'�Hs�%�j�ldyg�����Ԅ�f��đ��)�ѻ�gb�L��K��;7r)գC�1��	�lN�vKϣ!���Qr$9�P�ZI� u�'�a��=[�6/e
+�Y;�Ԝ��q�(^g>��2�B�äh��'�G��~���C�7H��d�Cҷ���ΗS�ݛʭ�a����^E�+�P�\#]�=]�F�hI�x��4�s �	

data/Changelog.md

@@ -1,3 +1,70 @@
+### 3.0.0.beta2 / 2014-02-17
+[full changelog](http://github.com/rspec/rspec-mocks/compare/v3.0.0.beta1...v3.0.0.beta2)
+
+Breaking Changes for 3.0.0:
+
+* Rename `RSpec::Mocks::Mock` to `RSpec::Mocks::Double`. (Myron Marston)
+* Change how to integrate rspec-mocks in other test frameworks. You now
+  need to include `RSpec::Mocks::ExampleMethods` in your test context.
+  (Myron Marston)
+* Prevent RSpec mocks' doubles and partial doubles from being used outside of
+  the per-test lifecycle (e.g. from a `before(:all)` hook). (Sam Phippen)
+* Remove the `host` argument of `RSpec::Mocks.setup`. Instead
+  `RSpec::Mocks::ExampleMethods` should be included directly in the scope where
+  RSpec's mocking capabilities are used. (Sam Phippen)
+* Make test doubles raise errors if you attempt to use them after they
+  get reset, to help surface issues when you accidentally retain
+  references to test doubles and attempt to reuse them in another
+  example. (Myron Marston)
+* Remove support for `and_return { value }` and `and_return` without arguments. (Yuji Nakayama)
+
+Enhancements:
+
+* Add `receive_message_chain` which provides the functionality of the old
+  `stub_chain` for the new allow/expect syntax. Use it like so: `allow(...).to
+  receive_message_chain(:foo, :bar, :bazz)`. (Sam Phippen).
+* Change argument matchers to use `===` as their primary matching
+  protocol, since their semantics mirror that of a case or rescue statement
+  (which uses `===` for matching). (Myron Marston)
+* Add `RSpec::Mocks.with_temporary_scope`, which allows you to create
+  temporary rspec-mocks scopes in arbitrary places (such as a
+  `before(:all)` hook). (Myron Marston)
+* Support keyword arguments when checking arity with verifying doubles.
+  (Xavier Shay)
+
+Bug Fixes:
+
+* Fix regression in 3.0.0.beta1 that caused `double("string_name" => :value)`
+  to stop working. (Xavier Shay)
+* Fix the way rspec-mocks and rspec-core interact so that if users
+  define a `let` with the same name as one of the methods
+  from `RSpec::Mocks::ArgumentMatchers`, the user's `let` takes
+  precedence. (Michi Huber, Myron Marston)
+* Fix verified doubles so that their methods match the visibility
+  (public, protected or private) of the interface they verify
+  against. (Myron Marston)
+* Fix verified null object doubles so that they do not wrongly
+  report that they respond to anything. They only respond to methods
+  available on the interface they verify against. (Myron Marston)
+* Fix deprecation warning for use of old `:should` syntax w/o explicit
+  config so that it no longer is silenced by an extension gem such
+  as rspec-rails when it calls `config.add_stub_and_should_receive_to`.
+  (Sam Phippen)
+* Fix `expect` syntax so that it does not wrongly emit a "You're
+  overriding a previous implementation for this stub" warning when
+  you are not actually doing that. (Myron Marston)
+* Fix `any_instance.unstub` when used on sub classes for whom the super
+  class has had `any_instance.stub` invoked on. (Jon Rowe)
+* Fix regression in `stub_chain`/`receive_message_chain` that caused
+  it to raise an `ArgumentError` when passing args to the stubbed
+  methods. (Sam Phippen)
+* Correct stub of undefined parent modules all the way down when stubbing a
+  nested constant. (Xavier Shay)
+* Raise `VerifyingDoubleNotDefinedError` when a constant is not defined for
+  a verifying class double. (Maurício Linhares)
+* Remove `Double#to_str`, which caused confusing `raise some_double`
+  behavior. (Maurício Linhares)
+
 ### 3.0.0.beta1 / 2013-11-07
 [full changelog](http://github.com/rspec/rspec-mocks/compare/v2.99.0.beta1...v3.0.0.beta1)
 
@@ -31,8 +98,8 @@ Enhancements:
   (Xavier Shay)
 * Provide `object_double` to create verified doubles of specific object
   instances. (Xavier Shay)
-* Provide 'verify_partial_doubles` configuration that provides `object_double`
-  like verification behaviour on partial mocks. (Xavier Shay)
+* Provide `verify_partial_doubles` configuration that provides `object_double`
+  like verification behaviour on partial doubles. (Xavier Shay)
 * Improved performance of double creation, particularly those with many
   attributes. (Xavier Shay)
 * Default value of `transfer_nested_constants` option for constant stubbing can
@@ -50,7 +117,7 @@ Enhancements:
 Deprecations:
 
 * Using the old `:should` syntax without explicitly configuring it
-  is disabled. It will continue to work but will emit a deprecation
+  is deprecated. It will continue to work but will emit a deprecation
   warning in RSpec 3 if you do not explicitly enable it. (Sam Phippen)
 
 Bug Fixes:
@@ -62,6 +129,21 @@ Bug Fixes:
   returns `nil` or `''` so that you still get a useful message.
   (Nick DeLuca)
 
+### 2.99.0.beta2 / 2014-02-17
+[full changelog](http://github.com/rspec/rspec-mocks/compare/v2.99.0.beta1...v2.99.0.beta2)
+
+Deprecations:
+
+* Deprecate `RSpec::Mocks::Mock` in favor of `RSpec::Mocks::Double`.
+  (Myron Marston)
+* Deprecate the `host` argument of `RSpec::Mocks.setup`. Instead
+  `RSpec::Mocks::ExampleMethods` should be included directly in the scope where
+  RSpec's mocking capabilities are used. (Sam Phippen)
+* Deprecate using any of rspec-mocks' features outside the per-test
+  lifecycle (e.g. from a `before(:all)` hook). (Myron Marston)
+* Deprecate re-using a test double in another example. (Myron Marston)
+* Deprecate `and_return { value }` and `and_return` without arguments. (Yuji Nakayama)
+
 ### 2.99.0.beta1 / 2013-11-07
 [full changelog](http://github.com/rspec/rspec-mocks/compare/v2.14.4...v2.99.0.beta1)
 
@@ -87,6 +169,16 @@ Enhancements:
 * Add a config option to yield the receiver to `any_instance` implementation
   blocks. (Sam Phippen)
 
+### 2.14.5 / 2014-02-01
+[full changelog](http://github.com/rspec/rspec-mocks/compare/v2.14.4...v2.14.5)
+
+Bug Fixes:
+
+* Fix regression that caused block implementations to not receive all
+  args on 1.8.7 if the block also receives a block, due to Proc#arity
+  reporting `1` no matter how many args the block receives if it
+  receives a block, too. (Myron Marston)
+
 ### 2.14.4 / 2013-10-15
 [full changelog](http://github.com/rspec/rspec-mocks/compare/v2.14.3...v2.14.4)
 

data/README.md

@@ -11,14 +11,28 @@ alike.
 
 ## Test Doubles
 
-A Test Double is an object that stands in for a real object in a test.
-RSpec creates test doubles that support method stubs and message
-expectations.
+A test double is an object that stands in for another object in your system
+during a code example. Use the `double` method, passing in an optional identifier, to create one:
 
 ```ruby
 book = double("book")
 ```
 
+Most of the time you will want some confidence that your doubles resemble an
+existing object in your system. Verifying doubles are provided for this
+purpose. If the existing object is available, they will prevent you from adding
+stubs and expectations for methods that do not exist or that have an invalid
+number of parameters.
+
+```ruby
+book = instance_double("Book", :pages => 250)
+```
+
+Verifying doubles have some clever tricks to enable you to both test in
+isolation without your dependencies loaded while still being able to validate
+them against real objects. More detail is available in [their
+documentation](https://github.com/rspec/rspec-mocks/blob/master/features/verifying_doubles).
+
 ## Method Stubs
 
 A method stub is an implementation that returns a pre-determined value.  Method
@@ -49,7 +63,7 @@ This is particularly nice when providing a list of test doubles to a method
 that iterates through them:
 
 ```ruby
-order.calculate_total_price(double(:price => 1.99),double(:price => 2.99))
+order.calculate_total_price(double(:price => 1.99), double(:price => 2.99))
 ```
 
 ## Consecutive return values
@@ -59,7 +73,7 @@ arguments to `and_return`.  The invocations cycle through the list. The last
 value is returned for any subsequent invocations:
 
 ```ruby
-allow(die).to receive(:roll).and_return(1,2,3)
+allow(die).to receive(:roll).and_return(1, 2, 3)
 die.roll # => 1
 die.roll # => 2
 die.roll # => 3
@@ -125,7 +139,7 @@ generic kind of object: a Test Double.
 
 ### Test-Specific Extension
 
-a.k.a. Partial Stub/Mock, a Test-Specific Extension is an extension of a
+a.k.a. Partial Double, a Test-Specific Extension is an extension of a
 real object in a system that is instrumented with test-double like
 behaviour in the context of a test. This technique is very common in Ruby
 because we often see class objects acting as global namespaces for methods.
@@ -206,7 +220,7 @@ expect(double).to receive(:msg).any_number_of_times
 ```ruby
 expect(double).to receive(:msg).ordered
 expect(double).to receive(:other_msg).ordered
-  #This will fail if the messages are received out of order
+  # This will fail if the messages are received out of order
 ```
 
 This can include the same message with different arguments:
@@ -234,11 +248,11 @@ expect(double).to receive(:msg).and_return(value)
 expect(double).to receive(:msg).exactly(3).times.and_return(value1, value2, value3)
   # returns value1 the first time, value2 the second, etc
 expect(double).to receive(:msg).and_raise(error)
-  #error can be an instantiated object or a class
-  #if it is a class, it must be instantiable with no args
+  # error can be an instantiated object or a class
+  # if it is a class, it must be instantiable with no args
 expect(double).to receive(:msg).and_throw(:msg)
-expect(double).to receive(:msg).and_yield(values,to,yield)
-expect(double).to receive(:msg).and_yield(values,to,yield).and_yield(some,other,values,this,time)
+expect(double).to receive(:msg).and_yield(values, to, yield)
+expect(double).to receive(:msg).and_yield(values, to, yield).and_yield(some, other, values, this, time)
   # for methods that yield to a block multiple times
 ```
 
@@ -249,8 +263,8 @@ allow(double).to receive(:msg).and_return(value)
 allow(double).to receive(:msg).and_return(value1, value2, value3)
 allow(double).to receive(:msg).and_raise(error)
 allow(double).to receive(:msg).and_throw(:msg)
-allow(double).to receive(:msg).and_yield(values,to,yield)
-allow(double).to receive(:msg).and_yield(values,to,yield).and_yield(some,other,values,this,time)
+allow(double).to receive(:msg).and_yield(values, to, yield)
+allow(double).to receive(:msg).and_yield(values, to, yield).and_yield(some, other, values, this, time)
 ```
 
 ## Arbitrary Handling

data/features/README.md

@@ -15,20 +15,28 @@ 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:
+during a code example. Use the `double` method, passing in an optional identifier, to create one:
 
-    double_account = double("Account")
+    book = double("book")
 
-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.
+Most of the time you will want some confidence that your doubles resemble an
+existing object in your system. Verifying doubles are provided for this
+purpose. If the existing object is available, they will prevent you from adding
+stubs and expectations for methods that do not exist or that have an invalid
+number of parameters.
+
+    book = instance_double("Book", :pages => 250)
+
+Verifying doubles have some clever tricks to enable you to both test in
+isolation without your dependencies loaded while still being able to validate
+them against real objects.
 
 ## 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 }
+    allow(die).to receive(:roll) { 3 }
 
 This tells the `die` object to return the value `3` when it receives the `roll`
 message.
@@ -45,7 +53,7 @@ specific message during the course of a code example:
           account = Account.new
           account.logger = logger
 
-          logger.should_receive(:account_closed).with(account)
+          expect(logger).to receive(:account_closed).with(account)
 
           account.close
         end

data/features/argument_matchers/README.md

@@ -4,10 +4,10 @@ Argument matchers can be used:
 
 * In stubs to constrain the scope of the stubbed method
 
-    obj.stub(:foo).with(:bar) do |arg|
+    allow(obj).to receive(:foo).with(:bar) do |arg|
       #do something for :bar
     end
-    obj.stub(:foo).with(:baz) do |arg|
+    allow(obj).to receive(:foo).with(:baz) do |arg|
       #do something for :baz
     end
 
@@ -17,11 +17,11 @@ Argument matchers can be used:
     obj = double()
 
     #expect a message with given args
-    obj.should_receive(:message).with('an argument')
+    expect(obj).to receive(:message).with('an argument')
 
 If more control is needed, one can use a block
 
-    obj.should_receive(:message) do |arg1,  arg2|
+    expect(obj).to receive(:message) do |arg1,  arg2|
       # set expectations about the args in this block
       # and optionally set a return value
-    end
+    end

data/features/argument_matchers/explicit.feature

@@ -8,15 +8,15 @@ Feature: explicit arguments
       describe "stubbed explicit arguments" do
         it "works on stubs" do
           object = Object.new
-          object.stub(:foo).with(:this) do |arg|
+          allow(object).to receive(:foo).with(:this) do |arg|
             "got this"
           end
-          object.stub(:foo).with(:that) do |arg|
+          allow(object).to receive(:foo).with(:that) do |arg|
             "got that"
           end
 
-          object.foo(:this).should eq("got this")
-          object.foo(:that).should eq("got that")
+          expect(object.foo(:this)).to eq("got this")
+          expect(object.foo(:that)).to eq("got that")
         end
 
         it "works on doubles and expectations" do
@@ -36,10 +36,10 @@ Feature: explicit arguments
       describe "stubbed multiple explicit arguments" do
         it "works on stubs" do
           object = Object.new
-          object.stub(:foo).with(:this) do |arg|
+          allow(object).to receive(:foo).with(:this) do |arg|
             "got this"
           end
-          object.stub(:foo).with(:this, :that) do |arg1, arg2|
+          allow(object).to receive(:foo).with(:this, :that) do |arg1, arg2|
             "got this and that"
           end
 

data/features/argument_matchers/general_matchers.feature

@@ -11,7 +11,7 @@ Feature: General matchers
       describe "stubbed anything() args spec" do
         it "works" do
           object = Object.new
-          object.stub(:foo).with(anything) do
+          allow(object).to receive(:foo).with(anything) do
             "anything"
           end
 
@@ -29,7 +29,7 @@ Feature: General matchers
       describe "stubbed any_args() args spec" do
         it "works" do
           object = Object.new
-          object.stub(:foo).with(any_args) do
+          allow(object).to receive(:foo).with(any_args) do
             "anything"
           end
 
@@ -48,10 +48,10 @@ Feature: General matchers
       describe "stubbed no_args() args spec" do
         it "works for no args" do
           object = Object.new
-          object.stub(:foo).with(no_args) do
+          allow(object).to receive(:foo).with(no_args) do
             "nothing"
           end
-          object.stub(:foo).with(anything) do
+          allow(object).to receive(:foo).with(anything) do
             "something"
           end
 

data/features/argument_matchers/type_matchers.feature

@@ -10,10 +10,10 @@ Feature: stub with argument constraints
       describe "stubbed an_instance_of() args spec" do
         it "works" do
           object = Object.new
-          object.stub(:foo).with(an_instance_of(Symbol)) do
+          allow(object).to receive(:foo).with(an_instance_of(Symbol)) do
             "symbol"
           end
-          object.stub(:foo).with(an_instance_of(String)) do
+          allow(object).to receive(:foo).with(an_instance_of(String)) do
             "string"
           end
 

data/features/message_expectations/README.md

@@ -4,12 +4,14 @@
     obj = double()
 
     # expect a message
-    obj.should_receive(:message)
+    expect(obj).to receive(:message)
 
     # specify a return value
-    obj.should_receive(:message) { :value }
-    obj.should_receive(:message => :value)
-    obj.should_receive(:message).and_return(:value)
+    expect(obj).to receive(:message) { :value }
+    expect(obj).to receive(:message).and_return(:value)
+
+    # specify multiple message/return value pairs
+    expect(obj).to receive_messages(:message => :value, :another_message => :another_value)
 
 These forms are somewhat interchangeable. The difference is that the
 block contents are evaluated lazily when the `obj` receives the
@@ -17,57 +19,57 @@ block contents are evaluated lazily when the `obj` receives the
 
 ### Fake implementation
 
-    obj.should_receive(:message) do |arg1, arg2|
+    expect(obj).to receive(:message) do |arg1, arg2|
       # set expectations about the args in this block
       # and set a return value
     end
 
 ### Using the original implementation
 
-    obj.should_receive(:message).and_call_original
+    expect(obj).to receive(:message).and_call_original
 
 ### Raising/Throwing
 
-    obj.should_receive(:message).and_raise("this error")
-    obj.should_receive(:message).and_throw(:this_symbol)
+    expect(obj).to receive(:message).and_raise("this error")
+    expect(obj).to 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 }
+    expect(obj).to receive(:message) { raise "this error" }
+    expect(obj).to 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')
+    expect(obj).to receive(:message).with('an argument')
+    expect(obj).to 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'))
+    expect(obj).to receive(:message).with(anything())
+    expect(obj).to receive(:message).with(an_instance_of(Money))
+    expect(obj).to receive(:message).with(hash_including(:a => 'b'))
 
 #### Regular expressions
 
-    obj.should_receive(:message).with(/abc/)
+    expect(obj).to receive(:message).with(/abc/)
 
 ### Counts
 
-    obj.should_receive(:message).once
-    obj.should_receive(:message).twice
-    obj.should_receive(:message).exactly(3).times
+    expect(obj).to receive(:message).once
+    expect(obj).to receive(:message).twice
+    expect(obj).to 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
+    expect(obj).to receive(:message).at_least(:once)
+    expect(obj).to receive(:message).at_least(:twice)
+    expect(obj).to 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
+    expect(obj).to receive(:message).at_most(:once)
+    expect(obj).to receive(:message).at_most(:twice)
+    expect(obj).to receive(:message).at_most(n).times
 
 ### Ordering
 
-    obj.should_receive(:one).ordered
-    obj.should_receive(:two).ordered
+    expect(obj).to receive(:one).ordered
+    expect(obj).to receive(:two).ordered