flexmock 1.0.0.beta.4 → 1.0.0

data/README.rdoc

@@ -1,16 +1,16 @@
-= Flex Mock -- Making Mock Easy
+= Flex Mock -- Making Mocking Easy
 
 FlexMock is a simple, but flexible, mock object library for Ruby unit
 testing.
 
-Version :: 1.0.0.beta.4
+Version :: 1.0.0
 
 = Links
 
-<b>Documents</b>                      :: http://flexmock.rubyforge.org
-<b>RubyGems</b>                       :: Install with: <b>gem install flexmock</b>
-<b>Source</b>                         :: https://github.com/jimweirich/flexmock
-<b>Bug Reports and Issue Tracking</b> :: https://github.com/jimweirich/flexmock/issues
+<b>Documents</b>                    :: http://flexmock.rubyforge.org
+<b>RubyGems</b>                     :: Install with: <b>gem install flexmock</b>
+<b>Source</b>                       :: https://github.com/jimweirich/flexmock
+<b>Bug Reports / Issue Tracking</b> :: https://github.com/jimweirich/flexmock/issues
 
 == Installation
 
@@ -181,10 +181,11 @@ FlexMock::MockContainer#flexmock for more details.
 
   * should_receive
   * new_instances
-  * any_instance  (note: deprecated)
-  * mock
-  * mock_teardown
-  * mock_setup
+  * flexmock_get
+  * flexmock_teardown
+  * flexmock_verify
+  * flexmock_received?
+  * flexmock_calls
 
 * <b>mock = flexmock(...) { |mock| mock.should_receive(...) }</b>
 
@@ -664,6 +665,7 @@ library in the <code>Mocha</code> project.
 
 FlexMock supports spy-like mocks as well as the traditional mocks.
 
+  # In Test::Unit / MiniTest
   class TestDogBarking < Test::Unit::TestCase
     def test_dog
       dog = flexmock(:on, Dog)
@@ -672,6 +674,44 @@ FlexMock supports spy-like mocks as well as the traditional mocks.
     end
   end
 
+  # In RSpec
+  describe Dog do
+    let(:dog) { flexmock(:on, Dog) }
+    it "barks loudly" do
+      dog.bark("loud")
+      dog.should have_received(:bark).with("loud")
+    end
+  end
+
+Since spies are verified after the code under test is run, they fit
+very nicely with the Given/When/Then technique of specification. Here
+is the above RSpec example using the rspec-given gem:
+
+  require 'rspec/given'
+
+  describe Dog do
+    Given(:dog) { flexmock(:on, Dog) }
+
+    context "when barking loudly" do
+      When { dog.bark("loud") }
+      Then { dog.should have_received(:bark).with("loud") }
+    end
+  end
+
+*NOTE:* You can only spy on methods that are mocked or stubbed. That's
+not a problem with regular mocks, but normal methods on partial
+objects will not be recorded.
+
+You can get around this limitation by stubbing the method in question
+on the normal mock, and then specifying <code>pass_thru</code>.
+Assuming <code.:bark</code> is a normal method on a Dog object, then
+the following allows for spying on <code>:bark</code>.
+
+   dog = Dog.new
+   flexmock(dog).should_receive(:bark).pass_thru
+   # ...
+   dog.should have_received(:bark)
+
 ==== Asserting Spy Methods are Called (Test::Unit / MiniTest)
 
 FlexMock provied a custom assertion method for use with Test::Unit and
@@ -909,173 +949,14 @@ beforehand.
 
 == Examples
 
-=== Create a simple mock object that returns a value for a set of method calls
-
-   require 'flexmock/test_unit'
-
-   class TestSimple < Test::Unit::TestCase
-     def test_simple_mock
-       m = flexmock(:pi => 3.1416, :e => 2.71)
-       assert_equal 3.1416, m.pi
-       assert_equal 2.71, m.e
-     end
-   end
-
-=== Create a mock object that returns an undefined object for method calls
-
-   require 'flexmock/test_unit'
-
-   class TestUndefined < Test::Unit::TestCase
-     def test_undefined_values
-       m = flexmock("mock")
-       m.should_receive(:divide_by).with(0).
-         and_return_undefined
-       assert_equal FlexMock.undefined, m.divide_by(0)
-     end
-   end
-
-=== Expect multiple queries and a single update
-
-Multiple calls to the query method will be allows, and calls may have any
-argument list. Each call to query will return the three element array [1, 2,
-3]. The call to update must have a specific argument of 5.
-
-   require 'flexmock/test_unit'
-
-   class TestDb < Test::Unit::TestCase
-     def test_db
-       db = flexmock('db')
-       db.should_receive(:query).and_return([1,2,3])
-       db.should_receive(:update).with(5).and_return(nil).once
-       # test code here
-     end
-   end
-
-=== Expect all queries before any updates
-
-(This and following examples assume that the 'flexmock/test_unit' file has
-been required.)
-
-All the query message must occur before any of the update messages.
-
-   def test_query_and_update
-     db = flexmock('db')
-     db.should_receive(:query).and_return([1,2,3]).ordered
-     db.should_receive(:update).and_return(nil).ordered
-     # test code here
-   end
-
-=== Expect several queries with different parameters
-
-The queries should happen after startup but before finish.  The
-queries themselves may happen in any order (because they are in the
-same order group).  The first two queries should happen exactly once,
-but the third query (which matches any query call with a four
-character parameter) may be called multiple times (but at least once).
-Startup and finish must also happen exactly once.
-
-Also note that we use the <code>with</code> method to match different
-argument values to figure out what value to return.
-
-   def test_ordered_queries
-     db = flexmock('db')
-     db.should_receive(:startup).once.ordered
-     db.should_receive(:query).with("CPWR").and_return(12.3).
-       once.ordered(:queries)
-     db.should_receive(:query).with("MSFT").and_return(10.0).
-       once.ordered(:queries)
-     db.should_receive(:query).with(/^....$/).and_return(3.3).
-       at_least.once.ordered(:queries)
-     db.should_receive(:finish).once.ordered
-     # test code here
-   end
-
-=== Same as above, but using the Record Mode interface
-
-The record mode interface offers much the same features as the
-<code>should_receive</code> interface introduced so far, but it allows
-the messages to be sent directly to a recording object rather than be
-specified indirectly using a symbol.
-
-   def test_ordered_queries_in_record_mode
-     db = flexmock('db')
-     db.should_expect do |rec|
-       rec.startup.once.ordered
-       rec.query("CPWR") { 12.3 }.once.ordered(:queries)
-       rec.query("MSFT") { 10.0 }.once.ordered(:queries)
-       rec.query(/^....$/) { 3.3 }.at_least.once.ordered(:queries)
-       rec.finish.once.ordered
-     end
-     # test code here using +db+.
-   end
-
-=== Using Record Mode to record a known, good algorithm for testing
-
-Record mode is nice when you have a known, good algorithm that can use
-a recording mock object to record the steps.  Then you compare the
-execution of a new algorithm to behavior of the old using the recorded
-expectations in the mock.  For this you probably want to put the
-recorder in _strict_ mode so that the recorded expectations use exact
-matching on argument lists, and strict ordering of the method calls.
-
-<b>Note:</b> This is most useful when there are no queries on the mock
-objects, because the query responses cannot be programmed into the
-recorder object.
-
-  def test_build_xml
-    builder = flexmock('builder')
-    builder.should_expect do |rec|
-      rec.should_be_strict
-      known_good_way_to_build_xml(rec)  # record the messages
-    end
-    new_way_to_build_xml(builder)       # compare to new way
-  end
-
-=== Expect multiple calls, returning a different value each time
-
-Sometimes you need to return different values for each call to a
-mocked method.  This example shifts values out of a list for this
-effect.
-
-   def test_multiple_gets
-     file = flexmock('file')
-     file.should_receive(:gets).with_no_args.
-        and_return("line 1\n", "line 2\n")
-     # test code here
-   end
-
-=== Ignore uninteresting messages
-
-Generally you need to mock only those methods that return an
-interesting value or wish to assert were sent in a particular manner.
-Use the <code>should_ignore_missing</code> method to turn on missing
-method ignoring.
-
-   def test_an_important_message
-     m = flexmock('m')
-     m.should_receive(:an_important_message).and_return(1).once
-     m.should_ignore_missing
-     # test code here
-   end
+Refer to the following documents for examples of using FlexMock:
 
-When <code>should_ignore_missing</code> is enabled, ignored missing
-methods will return an undefined object. Any operation on the
-undefined object will return the undefined object.
+* {RSpec Examples}[link:doc/examples/rspec_examples_spec_rdoc.html]
+* {Test::Unit / MiniTest Examples}[link:doc/examples/test_unit_examples_test_rdoc.html]
 
-=== Mock just one method on an existing object
-
-The Portfolio class calculate the value of a set of stocks by talking
-to a quote service via a web service.  Since we don't want to use a
-real web service in our unit tests, we will mock the quote service.
-
-  def test_portfolio_value
-    flexmock(QuoteService).new_instances do |m|
-      m.should_receive(:quote).and_return(100)
-    end
-    port = Portfolio.new
-    value = port.value     # Portfolio calls QuoteService.quote
-    assert_equal 100, value
-  end
+*NOTE:* <em>If the above links are not working, you probably need to
+read the documents from the {documentation
+site}[http://flexmock.rubyforge.org]</em>
 
 == License
 
@@ -1091,6 +972,12 @@ above copyright notice is included.
 Author::   Jim Weirich <jim.weirich@gmail.com>
 Requires:: Ruby 1.9.2 or later (Earlier versions of Flexmock may work with earlier versions of Ruby)
 
+== See Also
+
+If you like the spy capability of FlexMock, you should check out the
+rspec-given gem (http://rubygems.org/gems/rspec-given) that allows you
+to use Given/When/Then statements in you specifications.
+
 == Warranty
 
 This software is provided "as is" and without any express or

data/Rakefile

@@ -23,6 +23,11 @@ load './lib/flexmock/version.rb'
 
 PKG_VERSION = FlexMock::VERSION
 
+EXAMPLE_RB = FileList['doc/examples/*.rb']
+EXAMPLE_DOC = EXAMPLE_RB.ext('rdoc')
+
+CLOBBER.include(EXAMPLE_DOC)
+
 PKG_FILES = FileList[
   '[A-Z]*',
   'lib/**/*.rb',
@@ -36,7 +41,7 @@ RDOC_FILES = FileList[
   'CHANGES',
   'lib/**/*.rb',
   'doc/**/*.rdoc',
-]
+] + EXAMPLE_DOC
 
 task :default => [:test_all, :rspec]
 task :test_all => [:test]
@@ -84,6 +89,19 @@ file "html/index.html" => ["Rakefile"] + RDOC_FILES do
   sh "rdoc -o html --title FlexMock --line-numbers -m README.rdoc #{RDOC_FILES}"
 end
 
+EXAMPLE_RB.zip(EXAMPLE_DOC).each do |source, target|
+  file target => source do
+    open(source, "r") do |ins|
+      open(target, "w") do |outs|
+        outs.puts "= FlexMock Examples"
+        ins.each do |line|
+          outs.puts "    #{line}"
+        end
+      end
+    end
+  end
+end
+
 file "README.rdoc" => ["Rakefile", "lib/flexmock/version.rb"] do
   ruby %{-i.bak -pe '$_.sub!(/^Version *:: *((\\d+|beta|rc)\\.)+\\d+ *$/i, "Version :: #{PKG_VERSION}")' README.rdoc} # "
 end

data/doc/GoogleExample.rdoc

@@ -1,6 +1,8 @@
 = Extended FlexMock Example Using Google4R
 
-Google4R is a simple Ruby wrapper around the Google APIs.  In this extended example, we will use FlexMock to test software that uses the Google APIs, without every communicating with Google itself.
+Google4R is a simple Ruby wrapper around the Google APIs. In this
+extended example, we will use FlexMock to test software that uses the
+Google APIs, without every communicating with Google itself.
 
 == Purchase.rb
 
@@ -38,9 +40,11 @@ talking to the Google APIs. The config object given to the Purchase
 initializer is simply a hash of values defining the merchant_id, merchant_key
 and sandbox flag. To use the real Google checkout APIs, you will need to
 obtains a merchant id and key from Google. Since we will be mocking the Google
-interaction, we can use dummy values in our test.  
+interaction, we can use dummy values in our test.
 
-The tax table factory is required by the Google4R software.  We provide the following simplified one.  Read the Google API documents for more information.
+The tax table factory is required by the Google4R software. We provide
+the following simplified one. Read the Google API documents for more
+information.
 
   class TestTaxTableFactory
     def effective_tax_tables_at(time)
@@ -49,12 +53,14 @@ The tax table factory is required by the Google4R software.  We provide the foll
       tax_free_table.create_rule do |rule|
         rule.area = UsCountryArea.new(UsCountryArea::ALL)
         rule.rate = 0.0
-      end  
+      end
       return [tax_free_table]
     end
   end
 
-+Item+ is simply an ActiveRecord class that we are using to hold our purchase item information.  It should respond to the +name+, +description+ and +unit_price+ messages.
++Item+ is simply an ActiveRecord class that we are using to hold our
+purchase item information. It should respond to the +name+,
++description+ and +unit_price+ messages.
 
 == Testing Without Using External Resources
 
@@ -108,15 +114,15 @@ Here is the complete unit test:
         :name => "Deschutes",
         :description => "Deschutes model Guitar",
         :unit_price => Money.new(2400.00)))
-        
+
     flexmock(Google4R::Checkout::CheckoutCommand).new_instances do |instance|
       instance.should_receive(:send_to_google_checkout).once.
         and_return(flexmock(:redirect_url => "http://google.response.url"))
     end
 
     # Execute
-    p = Purchase.new({ 
-      :merchant_id => 'dummy_id', 
+    p = Purchase.new({
+      :merchant_id => 'dummy_id',
       :merchant_key => 'dummy_key',
       :use_sandbox => true })
     url = p.purchase(1)
@@ -124,27 +130,37 @@ Here is the complete unit test:
     # Assert
     assert_equal "http://google.response.url", url
   end
-  
+
 == Testing the Details
 
-The above test is fine as far as it goes. It demonstrates how to use mocks to
-avoid talking to external resources such as databases and web services.  But as a unit test, it is sorely lacking in several areas. 
+The above test is fine as far as it goes. It demonstrates how to use
+mocks to avoid talking to external resources such as databases and web
+services. But as a unit test, it is sorely lacking in several areas.
 
-All the test really demonstrates is that the +send_to_google_checkout+ method is called.  There are no tests to ensure that the right item descriptions and prices are correctly stored in the cart.  In fact, if we rewrote the purchase method as follows:
+All the test really demonstrates is that the +send_to_google_checkout+
+method is called. There are no tests to ensure that the right item
+descriptions and prices are correctly stored in the cart. In fact, if
+we rewrote the purchase method as follows:
 
   def purchase(item_id, quantity=1)
     @frontend.create_checkout_command.send_to_google_checkout.redirect_url
-  end  
+  end
 
-it would still pass the unit test we designed, even though the rewrite is obviously an incorrect implementation.
+it would still pass the unit test we designed, even though the rewrite
+is obviously an incorrect implementation.
 
 A more complete test is a bit more complicated.  Here are the details.
 
 === Mocking Active Record
 
-Our incorrect version of purchase never calls the +find+ method of Item.  We can easily test for that by adding a +once+ constraint one that mock specification.  Since find is a read-only method, we don't really care if it is called multiple times, as long as it is called at least one time, so we will add an +at_least+ modifier as well.
+Our incorrect version of purchase never calls the +find+ method of
+Item. We can easily test for that by adding a +once+ constraint one
+that mock specification. Since find is a read-only method, we don't
+really care if it is called multiple times, as long as it is called at
+least one time, so we will add an +at_least+ modifier as well.
 
-Finally, we are going to break the guitar mock out into its own declaration.  The reason will become obvious in a bit.
+Finally, we are going to break the guitar mock out into its own
+declaration. The reason will become obvious in a bit.
 
   mock_guitar = flexmock("guitar",
     :name => "Deschutes",
@@ -156,11 +172,19 @@ Finally, we are going to break the guitar mock out into its own declaration.  Th
 
 === Mocking a Cart Item
 
-The next bit is a wee bit complicated, but we will handle it a little bit at a time so that it doesn't become overwhelming.
+The next bit is a wee bit complicated, but we will handle it a little
+bit at a time so that it doesn't become overwhelming.
 
-There are three main objects in the Google checkout API that we deal with in the next section.:  (1) the checkout command object returned by the front end, (2) the cart object returned by the checkout command, and (3) the item passed to the block in the +create_item+ call.
+There are three main objects in the Google checkout API that we deal
+with in the next section.: (1) the checkout command object returned by
+the front end, (2) the cart object returned by the checkout command,
+and (3) the item passed to the block in the +create_item+ call.
 
-We will tackle them in reverse order, starting with the item objects given to the +create_item+ block.  The item must respond to four attribute assignments.  This is straightforward to mock, just make sure you include the +once+ constraint so that the assignments are required. 
+We will tackle them in reverse order, starting with the item objects
+given to the +create_item+ block. The item must respond to four
+attribute assignments. This is straightforward to mock, just make sure
+you include the +once+ constraint so that the assignments are
+required.
 
   mock_item = flexmock("item")
   mock_item.should_receive(:name=).with(mock_guitar.name).once
@@ -168,18 +192,24 @@ We will tackle them in reverse order, starting with the item objects given to th
   mock_item.should_receive(:unit_price=).with(mock_guitar.unit_price).once
   mock_item.should_receive(:quantity=).with(1).once
 
-Notice how we used the mock_guitar object defined earlier to provide values in the +with+ constraint.  This way we don't have to repeat the explicit strings and values we are checking.  (Keep it DRY!).
+Notice how we used the mock_guitar object defined earlier to provide
+values in the +with+ constraint. This way we don't have to repeat the
+explicit strings and values we are checking. (Keep it DRY!).
 
 === Mocking the Cart
 
-The mock cart object will pass the mock_item to a block when the +create_item+ method is called.  We specify that with the following:
+The mock cart object will pass the mock_item to a block when the
++create_item+ method is called. We specify that with the following:
 
   mock_cart = flexmock("cart")
   mock_cart.should_receive(:create_item).with(Proc).once.and_return { |block|
     block.call(mock_item)
   }
 
-FlexMock objects can handle blocks passed to them by treating them as the final object in the calling list.  Use +Proc+ in the +with+ constraint to match the block and then invoke the block explicitly via <tt>block.call(...)</tt> in the +and_return+ specification.
+FlexMock objects can handle blocks passed to them by treating them as
+the final object in the calling list. Use +Proc+ in the +with+
+constraint to match the block and then invoke the block explicitly via
+<tt>block.call(...)</tt> in the +and_return+ specification.
 
 === Mocking the Checkout Command
 
@@ -223,8 +253,8 @@ Here is the complete detailed version of the test method.
     end
 
     # Execute
-    p = Purchase.new({ 
-      :merchant_id => 'dummy_id', 
+    p = Purchase.new({
+      :merchant_id => 'dummy_id',
       :merchant_key => 'dummy_key',
       :use_sandbox => true })
     url = p.purchase(1)
@@ -253,9 +283,9 @@ Perhaps, but using mock objects have several definite advantages:
   your code correctly handle the case where you get an exception when
   connecting to google? Mocks can easily create those error conditions that
   are difficult to achieve with real objects.
-  
+
   E.g.
-  
+
      instance.should_receive(:send_to_google_checkout).once.
        and_return { raise Google4R::Checkout::GoogleCheckoutError }
 
@@ -272,4 +302,4 @@ expect it to. We don't actually care about the Google4R software itself in
 this test case (presumably we do have tests that cover Google4R, but those are
 different tests).
 
-In the end, mock objects are a power tool to have in your testing toolbox.
+In the end, mock objects are a powerful tool to have in your testing toolbox.

data/doc/examples/rspec_examples_spec.rdoc

@@ -0,0 +1,245 @@
+= FlexMock Examples
+    RSpec.configure do |config|
+      config.mock_with :flexmock
+    end
+    
+    describe "Simple Spec" do
+    
+      # Simple stubbing of some methods
+    
+      it "stubs a couple of methods" do
+        m = flexmock(:pi => 3.1416, :e => 2.71)
+        m.pi.should == 3.1416
+        m.e.should == 2.71
+      end
+    end
+    
+    
+    describe "Returning Undefined" do
+    
+      # Create a mock object that returns an undefined object for method calls
+    
+      it "returns undefined values" do
+        m = flexmock("mock")
+        m.should_receive(:divide_by).with(0).
+          and_return_undefined
+    
+        m.divide_by(0).should == FlexMock.undefined
+      end
+    end
+    
+    describe "Multiple Queries and Single Updates" do
+    
+      # Expect multiple queries and a single update
+    
+      # Multiple calls to the query method will be allows, and calls may
+      # have any argument list. Each call to query will return the three
+      # element array [1, 2, 3]. The call to update must have a specific
+      # argument of 5.
+    
+      it "queries the db" do
+        db = flexmock('db')
+        db.should_receive(:query).and_return([1,2,3])
+        db.should_receive(:update).with(5).and_return(nil).once
+    
+        # Test Code
+    
+        db.query
+        db.update(5)
+      end
+    end
+    
+    describe "Ordered Mocks" do
+    
+      # Expect all queries before any updates
+    
+      # All the query message must occur before any of the update
+      # messages.
+    
+      it "queries and updates the database" do
+        db = flexmock('db')
+        db.should_receive(:query).and_return([1,2,3]).ordered
+        db.should_receive(:update).and_return(nil).ordered
+    
+        # test code here
+    
+        db.query
+        db.update
+      end
+    end
+    
+    describe "Ordered Mocks" do
+    
+      # Expect several queries with different parameters
+    
+      # The queries should happen after startup but before finish. The
+      # queries themselves may happen in any order (because they are in
+      # the same order group). The first two queries should happen exactly
+      # once, but the third query (which matches any query call with a
+      # four character parameter) may be called multiple times (but at
+      # least once). Startup and finish must also happen exactly once.
+    
+      # Also note that we use the <code>with</code> method to match
+      # different argument values to figure out what value to return.
+    
+      it "queries the database in a particular order" do
+        db = flexmock('db')
+        db.should_receive(:startup).once.ordered
+        db.should_receive(:query).with("CPWR").and_return(12.3).
+          once.ordered(:queries)
+        db.should_receive(:query).with("MSFT").and_return(10.0).
+          once.ordered(:queries)
+        db.should_receive(:query).with(/^....$/).and_return(3.3).
+          at_least.once.ordered(:queries)
+        db.should_receive(:finish).once.ordered
+    
+        # Test Code
+    
+        db.startup
+        db.query("MSFT")
+        db.query("XYZY")
+        db.query("CPWR")
+        db.finish
+      end
+    end
+    
+    describe "Ordered Mocks" do
+    
+      # Same as above, but using the Record Mode interface
+    
+      # The record mode interface offers much the same features as the
+      # <code>should_receive</code> interface introduced so far, but it
+      # allows the messages to be sent directly to a recording object
+      # rather than be specified indirectly using a symbol.
+    
+    
+      it "records the queries for replay" do
+        db = flexmock('db')
+        db.should_expect do |rec|
+          rec.startup.once.ordered
+          rec.query("CPWR") { 12.3 }.once.ordered(:queries)
+          rec.query("MSFT") { 10.0 }.once.ordered(:queries)
+          rec.query(/^....$/) { 3.3 }.at_least.once.ordered(:queries)
+          rec.finish.once.ordered
+        end
+    
+        # Test Code
+    
+        db.startup
+        db.query("MSFT")
+        db.query("XYZY")
+        db.query("CPWR")
+        db.finish
+      end
+    end
+    
+    describe "Record Mode" do
+    
+      # Using Record Mode to record a known, good algorithm for testing
+    
+      # Record mode is nice when you have a known, good algorithm that can
+      # use a recording mock object to record the steps. Then you compare
+      # the execution of a new algorithm to behavior of the old using the
+      # recorded expectations in the mock. For this you probably want to
+      # put the recorder in _strict_ mode so that the recorded
+      # expectations use exact matching on argument lists, and strict
+      # ordering of the method calls.
+    
+      # <b>Note:</b> This is most useful when there are no queries on the
+      # mock objects, because the query responses cannot be programmed
+      # into the recorder object.
+    
+      it "compares a know algorithm with a new algorithm" do
+        builder = flexmock('builder')
+        builder.should_expect do |rec|
+          rec.should_be_strict
+          known_good_way_to_build_xml(rec)  # record the messages
+        end
+        new_way_to_build_xml(builder)       # compare to new way
+      end
+    
+      def known_good_way_to_build_xml(builder)
+        builder.person
+      end
+    
+      def new_way_to_build_xml(builder)
+        builder.person
+      end
+    
+    end
+    
+    describe "Multiple Return Values" do
+    
+      # Expect multiple calls, returning a different value each time
+    
+      # Sometimes you need to return different values for each call to a
+      # mocked method. This example shifts values out of a list for this
+      # effect.
+    
+      it "returns multiple values" do
+        file = flexmock('file')
+        file.should_receive(:gets).with_no_args.
+          and_return("line 1\n", "line 2\n")
+    
+        # test code here
+    
+        file.gets                   # returns "line 1"
+        file.gets                   # returns "line 2"
+      end
+    end
+    
+    describe "Ignore Unimportant Messages" do
+    
+      # Ignore uninteresting messages
+    
+      # Generally you need to mock only those methods that return an
+      # interesting value or wish to assert were sent in a particular
+      # manner. Use the <code>should_ignore_missing</code> method to turn
+      # on missing method ignoring.
+    
+      it "ignores unimportant messages" do
+        m = flexmock('m')
+        m.should_receive(:an_important_message).and_return(1).once
+        m.should_ignore_missing
+    
+        # Test Code
+    
+        m.an_important_message
+        m.an_unimportant_message
+      end
+    
+      # When <code>should_ignore_missing</code> is enabled, ignored
+      # missing methods will return an undefined object. Any operation on
+      # the undefined object will return the undefined object.
+    
+    end
+    
+    
+    describe "Partial Mocks" do
+    
+      # Mock just one method on an existing object
+    
+      # The Portfolio class calculate the value of a set of stocks by
+      # talking to a quote service via a web service. Since we don't want
+      # to use a real web service in our unit tests, we will mock the
+      # quote service.
+    
+      it "returns the portfolio value" do
+        flexmock(QuoteService).new_instances do |m|
+          m.should_receive(:quote).and_return(100)
+        end
+        port = Portfolio.new
+        value = port.value     # Portfolio calls QuoteService.quote
+        value.should == 100
+      end
+    
+      class QuoteService
+      end
+    
+      class Portfolio
+        def value
+          qs = QuoteService.new
+          qs.quote
+        end
+      end
+    end

data/doc/examples/test_unit_examples_test.rdoc

@@ -0,0 +1,241 @@
+= FlexMock Examples
+    require 'flexmock/test_unit'
+    
+    class TestSimple < Test::Unit::TestCase
+    
+      # Simple stubbing of some methods
+    
+      def test_simple_mock
+        m = flexmock(:pi => 3.1416, :e => 2.71)
+        assert_equal 3.1416, m.pi
+        assert_equal 2.71, m.e
+      end
+    end
+    
+    
+    class TestUndefined < Test::Unit::TestCase
+    
+      # Create a mock object that returns an undefined object for method calls
+    
+      def test_undefined_values
+        m = flexmock("mock")
+        m.should_receive(:divide_by).with(0).
+          and_return_undefined
+        assert_equal FlexMock.undefined, m.divide_by(0)
+      end
+    end
+    
+    class TestDb < Test::Unit::TestCase
+    
+      # Expect multiple queries and a single update
+    
+      # Multiple calls to the query method will be allows, and calls may
+      # have any argument list. Each call to query will return the three
+      # element array [1, 2, 3]. The call to update must have a specific
+      # argument of 5.
+    
+      def test_db
+        db = flexmock('db')
+        db.should_receive(:query).and_return([1,2,3])
+        db.should_receive(:update).with(5).and_return(nil).once
+    
+        # Test Code
+    
+        db.query
+        db.update(5)
+      end
+    end
+    
+    class TestOrdered < Test::Unit::TestCase
+    
+      # Expect all queries before any updates
+    
+      # All the query message must occur before any of the update
+      # messages.
+    
+      def test_query_and_update
+        db = flexmock('db')
+        db.should_receive(:query).and_return([1,2,3]).ordered
+        db.should_receive(:update).and_return(nil).ordered
+    
+        # test code here
+    
+        db.query
+        db.update
+      end
+    end
+    
+    class MoreOrdered < Test::Unit::TestCase
+    
+      # Expect several queries with different parameters
+    
+      # The queries should happen after startup but before finish. The
+      # queries themselves may happen in any order (because they are in
+      # the same order group). The first two queries should happen exactly
+      # once, but the third query (which matches any query call with a
+      # four character parameter) may be called multiple times (but at
+      # least once). Startup and finish must also happen exactly once.
+    
+      # Also note that we use the <code>with</code> method to match
+      # different argument values to figure out what value to return.
+    
+      def test_ordered_queries
+        db = flexmock('db')
+        db.should_receive(:startup).once.ordered
+        db.should_receive(:query).with("CPWR").and_return(12.3).
+          once.ordered(:queries)
+        db.should_receive(:query).with("MSFT").and_return(10.0).
+          once.ordered(:queries)
+        db.should_receive(:query).with(/^....$/).and_return(3.3).
+          at_least.once.ordered(:queries)
+        db.should_receive(:finish).once.ordered
+    
+        # Test Code
+    
+        db.startup
+        db.query("MSFT")
+        db.query("XYZY")
+        db.query("CPWR")
+        db.finish
+      end
+    end
+    
+    class EvenMoreOrderedTest < Test::Unit::TestCase
+    
+      # Same as above, but using the Record Mode interface
+    
+      # The record mode interface offers much the same features as the
+      # <code>should_receive</code> interface introduced so far, but it
+      # allows the messages to be sent directly to a recording object
+      # rather than be specified indirectly using a symbol.
+    
+    
+      def test_ordered_queries_in_record_mode
+        db = flexmock('db')
+        db.should_expect do |rec|
+          rec.startup.once.ordered
+          rec.query("CPWR") { 12.3 }.once.ordered(:queries)
+          rec.query("MSFT") { 10.0 }.once.ordered(:queries)
+          rec.query(/^....$/) { 3.3 }.at_least.once.ordered(:queries)
+          rec.finish.once.ordered
+        end
+    
+        # Test Code
+    
+        db.startup
+        db.query("MSFT")
+        db.query("XYZY")
+        db.query("CPWR")
+        db.finish
+      end
+    end
+    
+    class RecordedTest < Test::Unit::TestCase
+    
+      # Using Record Mode to record a known, good algorithm for testing
+    
+      # Record mode is nice when you have a known, good algorithm that can
+      # use a recording mock object to record the steps. Then you compare
+      # the execution of a new algorithm to behavior of the old using the
+      # recorded expectations in the mock. For this you probably want to
+      # put the recorder in _strict_ mode so that the recorded
+      # expectations use exact matching on argument lists, and strict
+      # ordering of the method calls.
+    
+      # <b>Note:</b> This is most useful when there are no queries on the
+      # mock objects, because the query responses cannot be programmed
+      # into the recorder object.
+    
+      def test_build_xml
+        builder = flexmock('builder')
+        builder.should_expect do |rec|
+          rec.should_be_strict
+          known_good_way_to_build_xml(rec)  # record the messages
+        end
+        new_way_to_build_xml(builder)       # compare to new way
+      end
+    
+      def known_good_way_to_build_xml(builder)
+        builder.person
+      end
+    
+      def new_way_to_build_xml(builder)
+        builder.person
+      end
+    
+    end
+    
+    class MultipleReturnValueTest < Test::Unit::TestCase
+    
+      # Expect multiple calls, returning a different value each time
+    
+      # Sometimes you need to return different values for each call to a
+      # mocked method. This example shifts values out of a list for this
+      # effect.
+    
+      def test_multiple_gets
+        file = flexmock('file')
+        file.should_receive(:gets).with_no_args.
+          and_return("line 1\n", "line 2\n")
+    
+        # test code here
+    
+        file.gets                   # returns "line 1"
+        file.gets                   # returns "line 2"
+      end
+    end
+    
+    class IgnoreUnimportantMessages < Test::Unit::TestCase
+    
+      # Ignore uninteresting messages
+    
+      # Generally you need to mock only those methods that return an
+      # interesting value or wish to assert were sent in a particular
+      # manner. Use the <code>should_ignore_missing</code> method to turn
+      # on missing method ignoring.
+    
+      def test_an_important_message
+        m = flexmock('m')
+        m.should_receive(:an_important_message).and_return(1).once
+        m.should_ignore_missing
+    
+        # Test Code
+    
+        m.an_important_message
+        m.an_unimportant_message
+      end
+    
+      # When <code>should_ignore_missing</code> is enabled, ignored
+      # missing methods will return an undefined object. Any operation on
+      # the undefined object will return the undefined object.
+    
+    end
+    
+    class PartialMockTest < Test::Unit::TestCase
+    
+      # Mock just one method on an existing object
+    
+      # The Portfolio class calculate the value of a set of stocks by
+      # talking to a quote service via a web service. Since we don't want
+      # to use a real web service in our unit tests, we will mock the
+      # quote service.
+    
+      def test_portfolio_value
+        flexmock(QuoteService).new_instances do |m|
+          m.should_receive(:quote).and_return(100)
+        end
+        port = Portfolio.new
+        value = port.value     # Portfolio calls QuoteService.quote
+        assert_equal 100, value
+      end
+    
+      class QuoteService
+      end
+    
+      class Portfolio
+        def value
+          qs = QuoteService.new
+          qs.quote
+        end
+      end
+    end

data/doc/releases/flexmock-1.0.0.rdoc

@@ -29,6 +29,8 @@ a few bug fixes.
 
 * Using the documented +singleton_methods+ method.
 
+* Accidently trying to partial mock a regular mock is now a no-op.
+
 == What is FlexMock?
 
 FlexMock is a flexible framework for creating mock object for testing. When

data/lib/flexmock/spy_describers.rb

@@ -14,7 +14,7 @@ class FlexMock
       def describe(spy, sym, args, options, not_clause="")
         result = "expected "
         result << call_description(sym, args)
-        result << " to#{not_clause} be called on "
+        result << " to#{not_clause} be received by "
         result << spy.inspect
         result << times_description(options[:times])
         result << block_description(options[:with_block])

data/lib/flexmock/version.rb

@@ -4,8 +4,6 @@ class FlexMock
       MAJOR = 1,
       MINOR = 0,
       BUILD = 0,
-      BETA = 'beta',
-      BETAREV = 4,
     ]
   end
 

data/test/assert_spy_called_test.rb

@@ -34,7 +34,7 @@ class AssertSpyCalledTest < Test::Unit::TestCase
 
   def test_assert_rejects_incorrect_args
     spy.foo(1,2)
-    messages = assert_fails(/^expected foo\(1, 3\) to be called on <FlexMock:AssertSpyCalledTest::FooBar Mock>/i) do
+    messages = assert_fails(/^expected foo\(1, 3\) to be received by <FlexMock:AssertSpyCalledTest::FooBar Mock>/i) do
       assert_spy_called spy, :foo, 1, 3
     end
   end
@@ -49,7 +49,7 @@ class AssertSpyCalledTest < Test::Unit::TestCase
   def test_assert_rejects_incorrect_type
     spy.foo
     spy.foo
-    assert_fails(/^expected foo\(\) to be called on <FlexMock:AssertSpyCalledTest::FooBar Mock> 3 times/i) do
+    assert_fails(/^expected foo\(\) to be received by <FlexMock:AssertSpyCalledTest::FooBar Mock> 3 times/i) do
       assert_spy_called spy, {times: 3}, :foo
     end
   end
@@ -71,7 +71,7 @@ class AssertSpyCalledTest < Test::Unit::TestCase
 
   def test_assert_rejects_bad_count_on_any_args
     spy.foo
-    assert_fails(/^expected foo\(\.\.\.\) to be called on <FlexMock:AssertSpyCalledTest::FooBar Mock> twice/i) do
+    assert_fails(/^expected foo\(\.\.\.\) to be received by <FlexMock:AssertSpyCalledTest::FooBar Mock> twice/i) do
       assert_spy_called spy, {times: 2}, :foo, :_
     end
   end

data/test/rspec_integration/spy_example_spec.rb

@@ -31,13 +31,13 @@ describe "Dog" do
     end
 
     it "rejects wag(:foot)" do
-      should_fail(/^expected wag\(:foot\) to be called on <FlexMock:Dog Mock>/i) do
+      should_fail(/^expected wag\(:foot\) to be received by <FlexMock:Dog Mock>/i) do
         dog.should have_received(:wag).with(:foot)
       end
     end
 
     it "rejects not wag(:tail)" do
-      should_fail(/^expected wag\(:foot\) to be called on <FlexMock:Dog Mock>/i) do
+      should_fail(/^expected wag\(:foot\) to be received by <FlexMock:Dog Mock>/i) do
         dog.should_not have_received(:wag).with(:tail)
       end
     end
@@ -58,7 +58,7 @@ describe "Dog" do
     end
 
     it "rejects wags(:tail) wrong times value" do
-      should_fail(/^expected wags\(:tail\) to be called on <FlexMock:Dog Mock>/i) do
+      should_fail(/^expected wags\(:tail\) to be received by <FlexMock:Dog Mock>/i) do
         dog.should have_received(:wags).with(:tail).times(2)
       end
     end
@@ -72,7 +72,7 @@ describe "Dog" do
     end
 
     it "rejects an incorrect once" do
-      should_fail(/^expected wags\(:tail\) to be called on <FlexMock:Dog Mock> once/i) do
+      should_fail(/^expected wags\(:tail\) to be received by <FlexMock:Dog Mock> once/i) do
         dog.should have_received(:wags).with(:tail).once
       end
     end
@@ -82,7 +82,7 @@ describe "Dog" do
     end
 
     it "rejects an incorrect twice" do
-      should_fail(/^expected wags\(:tail\) to be called on <FlexMock:Dog Mock> twice/) do
+      should_fail(/^expected wags\(:tail\) to be received by <FlexMock:Dog Mock> twice/) do
         dog.should have_received(:wags).with(:tail).twice
       end
     end
@@ -92,7 +92,7 @@ describe "Dog" do
     end
 
     it "rejects an incorrect never" do
-      should_fail(/^expected barks\(\) to be called on <FlexMock:Dog Mock> never/i) do
+      should_fail(/^expected barks\(\) to be received by <FlexMock:Dog Mock> never/i) do
         dog.should have_received(:barks).with().never
       end
     end

data/test/spys_test.rb

@@ -7,6 +7,7 @@ class TestSpys < Test::Unit::TestCase
 
   class FooBar
     def foo
+      :foofoo
     end
     def bar
     end
@@ -96,6 +97,20 @@ class TestSpys < Test::Unit::TestCase
     assert_spy_called @spy, :foo
   end
 
+  def test_spy_cannot_see_normal_methods
+    foo = FooBar.new
+    flexmock(foo)
+    assert_equal :foofoo, foo.foo
+    assert_spy_not_called foo, :foo
+  end
+
+  def test_spy_cannot_see_normal_methods2
+    foo = FooBar.new
+    flexmock(foo).should_receive(:foo).pass_thru
+    assert_equal :foofoo, foo.foo
+    assert_spy_called foo, :foo
+  end
+
   def test_calling_non_spy_base_methods_is_an_error
     assert_raise(NoMethodError) do
       @spy.baz

metadata

@@ -1,8 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: flexmock
 version: !ruby/object:Gem::Version 
-  prerelease: 6
-  version: 1.0.0.beta.4
+  prerelease: 
+  version: 1.0.0
 platform: ruby
 authors: 
 - Jim Weirich
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-08-22 00:00:00 Z
+date: 2012-08-23 00:00:00 Z
 dependencies: []
 
 description: "\n      FlexMock is a extremely simple mock object class compatible\n      with the Test::Unit framework.  Although the FlexMock's\n      interface is simple, it is very flexible.\n    "
@@ -22,6 +22,8 @@ extensions: []
 extra_rdoc_files: 
 - README.rdoc
 - CHANGES
+- doc/examples/rspec_examples_spec.rdoc
+- doc/examples/test_unit_examples_test.rdoc
 - doc/GoogleExample.rdoc
 - doc/releases/flexmock-0.4.0.rdoc
 - doc/releases/flexmock-0.4.1.rdoc
@@ -106,6 +108,8 @@ files:
 - test/undefined_test.rb
 - flexmock.blurb
 - install.rb
+- doc/examples/rspec_examples_spec.rdoc
+- doc/examples/test_unit_examples_test.rdoc
 - doc/GoogleExample.rdoc
 - doc/releases/flexmock-0.4.0.rdoc
 - doc/releases/flexmock-0.4.1.rdoc
@@ -148,9 +152,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version 
-      version: 1.3.1
+      version: "0"
 requirements: []
 
 rubyforge_project: