redinger-rr 0.10.3

data/CHANGES

@@ -0,0 +1,221 @@
+- Handle lazily defined methods (where respond_to? returns true yet the method is not yet defined and the first call to method_missing defines the method). This pattern is used in ActiveRecord and ActionMailer.
+- Fixed warning about aliasing #instance_exec in jruby. http://github.com/btakita/rr/issues#issue/9 (Patch by Nathan Sobo)
+
+0.10.2
+- RR properly proxies subjects with private methods [http://github.com/btakita/rr/issues/#issue/7]. Identified by Matthew O'Connor.
+
+0.10.1
+- Fixed issue with DoubleInjection not invoking methods that are lazily created [http://github.com/btakita/rr/issues/#issue/4]. Identified by davidlee (http://github.com/davidlee)
+- Fixed issue with mock.proxy and returns [http://github.com/btakita/rr/issues/#issue/2]. Identified by trogdoro (http://github.com/trogdoro)
+
+* 0.10.0
+- Method is no longer invoked if respond_to? returns false. This was in place to support ActiveRecord association proxies, and is no longer needed. 
+
+* 0.9.0
+- instance_of Doubles now apply to methods invoked in the subject's #initialize method.
+
+* 0.8.1
+- Fixed exception where the Subject uses method delegation via method_missing (e.g. certain ActiveRecord AssociationProxy methods)
+
+* 0.8.0
+- Fixed compatability issues with Ruby 1.9
+- Aliased any_number_of_times with any_times
+- Better error messages for have_received and assert_received matchers (Patch by Joe Ferris)
+- Better documentation on RR wilcard matchers (Patch by Phil Arnowsky)
+
+* 0.7.1
+- Performance improvements
+
+* 0.7.0
+- Added spies (Patchs by Joe Ferris, Michael Niessner & Mike Mangino)
+- Added strongly typed reimplementation doubles (Patch by Michael Niessner)
+
+* 0.6.2
+- Fixed DoubleDefinition chaining edge cases
+
+* 0.6.1
+- DoubleDefinitionCreatorProxy definition eval block is instance_evaled when the arity is not 1. When the arity is 1, the block is yielded with the DoubleDefinitionCreatorProxy passed in.
+ 
+* 0.6.0
+- Friendlier DoubleNotFound error message
+- Implemented Double strategy creation methods (#mock, #stub, #proxy, #instance_of, and ! equivalents) on DoubleDefinition
+- Implemented hash_including matcher (Patch by Matthew O'Conner)
+- Implemented satisfy matcher (Patch by Matthew O'Conner)
+- Implemented DoubleDefinitionCreator#mock!, #stub!, and #dont_allow!
+- Modified api to method chain Doubles
+- Fix conflict with Mocha overriding Object#verify
+
+* 0.5.0
+- Method chaining Doubles (Patch by Nick Kallen)
+- Chained ordered expectations (Patch by Nick Kallen)
+- Space#verify_doubles can take one or more objects with DoubleInjections to be verified
+
+* 0.4.10
+- DoubleDefinitionCreatorProxy does not undef #object_id
+- Fixed rdoc pointer to README
+
+* 0.4.9
+- Proxying from RR module to RR::Space.instance
+
+* 0.4.8
+- Fixed issue with Hash arguments
+
+* 0.4.7
+- Improved error message
+
+* 0.4.6
+- Added Double#verbose and Double#verbose?
+
+* 0.4.5
+- Fixed doubles for == and #eql? methods
+
+* 0.4.4
+- Doc improvements
+- Methods that are not alphabetic, such as ==, can be doubles
+
+* 0.4.3
+- Doc improvements
+- Cleanup
+- Finished renaming scenario to double
+
+* 0.4.2
+- Renamed DoubleInsertion to DoubleInjection to be consistent with Mocha terminology
+
+* 0.4.1
+- Fixed backward compatability issues with rspec
+- Renamed Space#verify_double_insertions to #verify_doubles
+
+* 0.4.0
+- Documentation improvements
+- Renamed Double to DoubleInsertion
+- Renamed Scenario to Double
+
+* 0.3.11
+- Fixed [#13724] Mock Proxy on Active Record Association proxies causes error
+
+* 0.3.10
+- Fixed [#13139] Blocks added to proxy sets the return_value and not the after_call callback
+
+* 0.3.9
+- Alias probe to proxy
+
+* 0.3.8
+- Implemented [#13009] Better error mesage from TimesCalledMatcher
+
+* 0.3.7
+- Fixed [#12928] Reset doubles fails on Rails association proxies
+
+* 0.3.6
+- Fixed [#12765] Issues with ObjectSpace._id2ref
+
+* 0.3.5
+- trim_backtrace is only set for Test::Unit
+
+* 0.3.4
+- Implemented instance_of
+
+* 0.3.3
+- Fixed [#12495] Error Probing method_missing interaction
+
+* 0.3.2
+- Fixed [#12486] ScenarioMethodProxy when Kernel passed into instance methods
+
+* 0.3.1
+- Automatically require Test::Unit and Rspec adapters
+
+* 0.3.0
+- ScenarioCreator strategy method chaining
+- Removed mock_probe
+- Removed stub_probe
+
+* 0.2.5
+- mock takes method_name argument
+- stub takes method_name argument
+- mock_probe takes method_name argument
+- stub_probe takes method_name argument
+- probe takes method_name argument
+- dont_allow takes method_name argument
+- do_not_allow takes method_name argument
+
+* 0.2.4
+- Space#doubles key is now the object id
+- Fixed [#12402] Stubbing return value of probes fails after calling the stubbed method two times
+
+* 0.2.3
+- Added RRMethods#rr_verify and RRMethods#rr_reset
+
+* 0.2.2
+- Fixed "singleton method bound for a different object"
+- Doing Method aliasing again to store original method
+
+* 0.2.1
+- Added mock_probe
+- Added stub_probe
+- Probe returns the return value of the passed in block, instead of ignoring its return value
+- Scenario#after_call returns the return value of the passed in block
+- Not using method aliasing to store original method
+- Renamed DoubleMethods to RRMethods
+- Added RRMethods#mock_probe
+
+* 0.1.15
+- Fixed [#12333] Rebinding original_methods causes blocks not to work
+
+* 0.1.14
+- Introduced concept of Terminal and NonTerminal TimesCalledMatchers
+- Doubles that can be called many times can be replaced
+- Terminal Scenarios are called before NonTerminal Scenarios
+- Error message tweaking
+- Raise error when making a Scenarios with NonTerminal TimesMatcher Ordered
+
+* 0.1.13
+- Fixed [#12290] Scenario#returns with false causes a return value of nil
+
+* 0.1.12
+- Fixed bug where Creators methods are not removed when methods are defined on Object
+- Fixed [#12289] Creators methods are not removed in Rails environment
+
+* 0.1.11
+- Fixed [#12287] AtLeastMatcher does not cause Scenario to be called
+
+* 0.1.10
+- Fixed [#12286] AnyArgumentExpectation#expected_arguments not implemented
+
+* 0.1.9
+- Added DoubleMethods#any_times
+- Added Scenario#any_number_of_times
+
+* 0.1.8
+- TimesCalledError Message Formatted to be on multiple lines
+- ScenarioNotFoundError Message includes all Scenarios for the Double
+- ScenarioOrderError shows list of remaining ordered scenarios
+
+* 0.1.7
+- Fixed [#12194] Double#reset_doubles are not clearing Ordered Scenarios bug
+- Added Space#reset
+- Space#reset_doubles and Space#reset_ordered_scenarios is now protected
+- Added Scenario#at_least
+- Added Scenario#at_most
+
+* 0.1.6
+- [#12120] probe allows a the return value to be intercepted
+
+* 0.1.5
+- TimesCalledExpectation says how many times were called and how many times called were expected on error
+
+* 0.1.4
+- TimesCalledError prints the backtrace to where the Scenario was defined when being verified
+- Error message includes method name when Scenario is not found
+
+* 0.1.3
+- Fixed issue where Double#placeholder_name issues when Double method name has a ! or ?
+
+* 0.1.2
+- Scenario#returns also accepts an argument
+- Implemented Scenario#yields
+
+* 0.1.1
+- Trim the backtrace for Rspec and Test::Unit
+- Rspec and Test::Unit integration fixes
+
+* 0.1.0
+- Initial Release

data/README.rdoc

@@ -0,0 +1,343 @@
+= RR
+
+RR (Double Ruby) is a test double framework that features a rich
+selection of double techniques and a terse syntax.
+
+== More Information
+=== Mailing Lists
+* double-ruby-users@rubyforge.org
+* double-ruby-devel@rubyforge.org
+
+=== Websites
+* http://rubyforge.org/projects/double-ruby
+* http://github.com/btakita/rr
+
+== What is a Test Double?
+A Test Double is a generalization of something that replaces a real
+object to make it easier to test another object. Its like a stunt
+double for tests. The following are test doubles:
+* Mocks
+* Stubs
+* Fakes
+* Spies
+* Proxies
+http://xunitpatterns.com/Test%20Double.html
+
+Currently RR implements mocks, stubs, proxies, and spies. Fakes usually require custom code, so it is beyond the scope of RR.
+
+== Using RR
+=== test/unit
+  class Test::Unit::TestCase
+    include RR::Adapters::TestUnit
+  end
+
+=== rspec
+  Spec::Runner.configure do |config|
+    config.mock_with :rr
+    # or if that doesn't work due to a version incompatibility
+    # config.mock_with RR::Adapters::Rspec
+  end
+
+== standalone
+  extend RR::Adapters::RRMethods
+  mock(object).method_name {:return_value}
+
+  object.method_name # Returns :return_value
+
+  RR.verify # Verifies the Double expectations are satisfied
+
+== Syntax between RR and other double/mock frameworks
+=== Terse Syntax
+One of the goals of RR is to make doubles more scannable.
+This is accomplished by making the double declaration look as much as the actual method invocation as possible.
+Here is RR compared to other mock frameworks:
+
+  flexmock(User).should_receive(:find).with('42').and_return(jane) # Flexmock
+  User.should_receive(:find).with('42').and_return(jane) # Rspec
+  User.expects(:find).with('42').returns {jane} # Mocha
+  User.should_receive(:find).with('42') {jane} # Rspec using return value blocks
+  mock(User).find('42') {jane} # RR
+
+=== Double Injections (a.k.a Partial Mocking)
+RR utilizes a technique known as "double injection".
+
+  my_object = MyClass.new
+  mock(my_object).hello
+
+Compare this with doing a mock in mocha:
+  my_mocked_object = mock()
+  my_mocked_object.expects(:hello)
+
+== Pure Mock objects
+If you wish to use objects for the sole purpose of being a mock, you can
+do so by creating an empty object.
+  mock(my_mock_object = Object.new).hello
+
+or by using mock!
+  my_mock_object = mock!.hello.subject # Mocks the #hello method and retrieves that object via the #subject method
+
+=== No should_receive or expects method
+RR uses method_missing to set your method expectation. This means you do not
+need to use a method such as should_receive or expects.
+
+  mock(my_object).hello # The hello method on my_object is mocked
+
+Mocha:
+  my_object.expects(:hello) # expects sets the hello method expectation
+Rspec mocks:
+  my_object.should_receive(:hello) # should_receive sets the hello method expectation
+
+=== with method call is not necessary
+Since RR uses method_missing, it also makes using the #with method unnecessary in most circumstances
+to set the argument expectations.
+
+  mock(my_object).hello('bob', 'jane')
+
+Mocha:
+  my_object.expects(:hello).with('bob', 'jane')
+Rspec mocks:
+  my_object.should_receive(:hello).with('bob', 'jane')
+
+=== using a block to set the return value
+RR supports using a block to set the return value. RR also has the #returns method.
+Both of the examples are equivalent.
+
+  mock(my_object).hello('bob', 'jane') {'Hello Bob and Jane'}
+  mock(my_object).hello('bob', 'jane').returns('Hello Bob and Jane')
+
+Mocha:
+  my_object.expects(:hello).with('bob', 'jane').returns('Hello Bob and Jane')
+Rspec mocks:
+  my_object.should_receive(:hello).with('bob', 'jane').and_return('Hello Bob and Jane')
+  my_object.should_receive(:hello).with('bob', 'jane') {'Hello Bob and Jane'} #rspec also supports blocks for the return value
+
+== Using RR
+To create a double on an object, you can use the following methods:
+* mock or mock!
+* stub or stub!
+* dont_allow or dont_allow!
+* proxy or proxy!
+* instance_of or instance_of!
+
+These methods are composable. mock, stub, and dont_allow can be used by themselves and
+are mutually exclusive.
+proxy and instance_of must be chained with mock or stub. You can also chain
+proxy and instance_of together.
+
+The ! (bang) version of these methods causes the subject object of the Double to be instantiated.
+
+=== mock
+mock replaces the method on the object with an expectation and implementation.
+The expectations are a mock will be called with certain arguments a certain
+number of times (the default is once). You can also set the return value
+of the method invocation.
+
+See http://xunitpatterns.com/Mock%20Object.html
+
+The following example sets an expectation that the view will receive a method
+call to #render with the arguments {:partial => "user_info"} once.
+When the method is called "Information" is returned.
+  view = controller.template
+  mock(view).render(:partial => "user_info") {"Information"}
+
+=== stub
+stub replaces the method on the object with only an implementation. You
+can still use arguments to differentiate which stub gets invoked.
+
+See http://xunitpatterns.com/Test%20Stub.html
+
+The following example makes the User.find method return jane when passed
+'42' and returns bob when passed '99'. If another id is passed to User.find,
+an exception is raised.
+  jane = User.new
+  bob = User.new
+  stub(User).find('42') {jane}
+  stub(User).find('99') {bob}
+  stub(User).find do |id|
+    raise "Unexpected id #{id.inspect} passed to me"
+  end
+
+=== dont_allow - aliased with do_not_allow, dont_call, and do_not_call
+dont_allow sets an expectation on the Double that it will never be called.
+If the Double is called, then a TimesCalledError is raised.
+  dont_allow(User).find('42')
+  User.find('42') # raises a TimesCalledError
+
+=== mock.proxy
+mock.proxy replaces the method on the object with an expectation, implementation, and
+also invokes the actual method. mock.proxy also intercepts the return value and
+passes it into the return value block.
+
+The following example makes sets an expectation that view.render({:partial => "right_navigation"})
+gets called once and return the actual content of the rendered partial template.
+A call to view.render({:partial => "user_info"}) will render the user_info
+partial template and send the content into the block and is represented by the html variable.
+An assertion is done on the html and "Different html" is returned.
+  view = controller.template
+  mock.proxy(view).render(:partial => "right_navigation")
+  mock.proxy(view).render(:partial => "user_info") do |html|
+    html.should include("John Doe")
+    "Different html"
+  end
+
+You can also use mock.proxy to set expectations on the returned value. In
+the following example, a call to User.find('5') does the normal ActiveRecord
+implementation and passes the actual value, represented by the variable bob,
+into the block. bob is then set with a mock.proxy for projects to return
+only the first 3 projects. bob is also mocked with valid? to return false.
+  mock.proxy(User).find('5') do |bob|
+    mock.proxy(bob).projects do |projects|
+      projects[0..3]
+    end
+    mock(bob).valid? {false}
+    bob
+  end
+
+=== stub.proxy
+Intercept the return value of a method call.
+The following example verifies render partial will be called and
+renders the partial.
+
+  view = controller.template
+  stub.proxy(view).render(:partial => "user_info") do |html|
+    html.should include("Joe Smith")
+    html
+  end
+
+=== instance_of
+Put double scenarios on instances of a Class.
+
+  mock.instance_of(User).valid? {false}
+
+=== Spies
+
+Adding a DoubleInjection to an Object + Method (done by stub, mock, or dont_allow) causes RR to record any method
+invocations to the Object + method. Assertions can then be made on the recorded method calls.
+
+==== test/unit
+
+  subject = Object.new
+  stub(subject).foo
+  subject.foo(1)
+  assert_received(subject) {|subject| subject.foo(1)}
+  assert_received(subject) {|subject| subject.bar} # This fails
+
+==== rspec
+
+  subject = Object.new
+  stub(subject).foo
+  subject.foo(1)
+  subject.should have_received.foo(1)
+  subject.should have_received.bar # this fails
+
+=== Block Syntax
+The block syntax has two modes
+* A normal block mode with a DoubleDefinitionCreatorProxy argument
+
+  script = MyScript.new
+  mock(script) do |expect|
+    expect.system("cd #{RAILS_ENV}") {true}
+    expect.system("rake foo:bar") {true}
+    expect.system("rake baz") {true}
+  end
+
+* An instance_eval mode where the DoubleDefinitionCreatorProxy is instance_evaled
+
+    script = MyScript.new
+    mock(script) do
+      system("cd #{RAILS_ENV}") {true}
+      system("rake foo:bar") {true}
+      system("rake baz") {true}
+    end
+
+=== Block Syntax with explicit DoubleDefinitionCreatorProxy argument
+
+
+=== Double Graphs
+RR has a method-chaining api support for Double graphs. For example,
+lets say you want an object to receive a method call to #foo, and have
+the return value receive a method call to #bar.
+
+In RR, you would do:
+  stub(object).foo.stub!.bar {:baz}
+  object.foo.bar # :baz
+  # or
+  stub(object).foo {stub!.bar {:baz}}
+  object.foo.bar # :baz
+  # or
+  bar = stub!.bar {:baz}
+  stub(object).foo {bar}
+  object.foo.bar # :baz
+
+=== Argument Wildcard matchers
+==== anything
+  mock(object).foobar(1, anything)
+  object.foobar(1, :my_symbol)
+
+==== is_a
+  mock(object).foobar(is_a(Time))
+  object.foobar(Time.now)
+
+==== numeric
+  mock(object).foobar(numeric)
+  object.foobar(99)
+
+==== boolean
+  mock(object).foobar(boolean)
+  object.foobar(false)
+
+==== duck_type
+  mock(object).foobar(duck_type(:walk, :talk))
+  arg = Object.new
+  def arg.walk; 'waddle'; end
+  def arg.talk; 'quack'; end
+  object.foobar(arg)
+
+==== Ranges
+  mock(object).foobar(1..10)
+  object.foobar(5)
+
+==== Regexps
+  mock(object).foobar(/on/)
+  object.foobar("ruby on rails")
+
+==== hash_including
+  mock(object).foobar(hash_including(:red => "#FF0000", :blue => "#0000FF"))
+  object.foobar({:red => "#FF0000", :blue => "#0000FF", :green => "#00FF00"})
+
+==== satisfy
+  mock(object).foobar(satisfy {|arg| arg.length == 2})
+  object.foobar("xy")
+
+==== Writing your own Argument Matchers
+Writing a custom argument wildcard matcher is not difficult.  See
+RR::WildcardMatchers for details.
+
+=== Invocation Amount Wildcard Matchers
+==== any_times
+  mock(object).method_name(anything).times(any_times) {return_value}
+
+== Special Thanks To
+With any development effort, there are countless people who have contributed
+to making it possible. We all are standing on the shoulders of giants.
+* Andreas Haller for patches
+* Aslak Hellesoy for Developing Rspec
+* Dan North for syntax ideas
+* Dave Astels for some BDD inspiration
+* David Chelimsky for encouragement to make the RR framework, for developing the Rspec mock framework, syntax ideas, and patches
+* Daniel Sudol for identifing performance issues with RR
+* Felix Morio for pairing with me
+* Gerard Meszaros for his excellent book "xUnit Test Patterns"
+* James Mead for developing Mocha
+* Jeff Whitmire for documentation suggestions
+* Jim Weirich for developing Flexmock, the first Terse ruby mock framework in Ruby
+* Joe Ferris for patches
+* Matthew O'Connor for patches and pairing with me
+* Michael Niessner for patches and pairing with me
+* Mike Mangino (from Elevated Rails) for patches and pairing with me
+* Nick Kallen for documentation suggestions, bug reports, and patches
+* Nathan Sobo for various ideas and inspiration for cleaner and more expressive code
+* Parker Thompson for pairing with me
+* Phil Darnowsky for patches
+* Pivotal Labs for sponsoring RR development
+* Stephen Baker for Developing Rspec