flexmock 1.0.0.beta.1 → 1.0.0.beta.2

data/CHANGES

@@ -1,5 +1,18 @@
 = Changes for FlexMock
 
+== Version 1.0.0
+
+* Added spy support.
+* Added base class mocking restrictions.
+* Using singleton_methods to get list of singleton methods (rather
+  than methods(false))
+* Correctly handling mocking methods that were meta-programmed with
+  method_missing.
+
+== Version 0.9.0
+
+* Ruby 1.9.3 compatibility changes.
+
 == Version 0.8.5
 
 * Fixed warning about a void context.
@@ -45,7 +58,7 @@
 
 * Updated install.rb to handle non-root destination directories via
   DESTDIR.
-* Fixed operator bug introduced in 0.7.0. 
+* Fixed operator bug introduced in 0.7.0.
 
 == Version 0.7.0
 
@@ -79,15 +92,15 @@
   where mock support methods in the domain object would cause
   problems.
 
-* Internally renamed PartialMock to PartialMockProxy.  
-	
+* Internally renamed PartialMock to PartialMockProxy.
+
 == Version 0.6.2
 
 * flexmock() with a block now always returns the domain object.
   flexmock() without a block returns the mock object.  Note that for
   normal mocks, the domain and mock objects are the same.  For partial
   mocks, the mock is separate from the domain object.
-* Added +and_raise+ to the list of expection specifications.	
+* Added +and_raise+ to the list of expection specifications.
 
 == Version 0.6.1
 
@@ -105,7 +118,7 @@
 
 == Version 0.5.1
 
-* Changed the name of any_instance to new_instances.  
+* Changed the name of any_instance to new_instances.
   Deprecated any_instance.
 * Added ability to stub any class method in new_instances.
 * Added RCov task
@@ -128,12 +141,12 @@
 == Version 0.4.3
 
 * Fixed bug where non-direct class methods were not properly handled.
-	
+
 == Version 0.4.2
 
 * Fixed bug where multiple stubs of a class method were not
   properly restored.
-	
+
 == Version 0.4.1
 
 * Removed include of Test::Unit::Assertions from Expectations.
@@ -167,8 +180,8 @@
 * Added strict mode in record mode interface to facility using known
   good algorithms for comparison testing.
 * Improved the docs and examples.  Fixed garbled first example in
-  README. 
-	
+  README.
+
 == Version 0.2.0
 
 * Added record mode for building expectations.

data/README.rdoc

@@ -3,15 +3,14 @@
 FlexMock is a simple, but flexible, mock object library for Ruby unit
 testing.
 
-Version :: 1.0.0.beta.1
+Version :: 1.0.0.beta.2
 
 = Links
 
-<b>Documents</b>   :: http://flexmock.rubyforge.org
-<b>RubyGems</b>    :: Install with: <b>gem install flexmock</b>
-<b>Download</b>    :: Download from RubyForge at http://rubyforge.org/frs/?group_id=3433 (pre 0.6.0 versions may be found at http://rubyforge.org/frs/?group_id=170)
-<b>Issue Tracking</b> :: http://www.pivotaltracker.com/projects/28401
-<b>Bug Reports</b>    :: http://onestepback.org/cgi-bin/bugs.cgi?project=flexmock
+<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
 
 == Installation
 
@@ -78,11 +77,11 @@ Your test case will look something like this:
     end
   end
 
-<b>NOTE:</b> If you don't want to automatically extend every TestCase with the
-flexmock methods and overhead, then require the 'flexmock' file and explicitly
-include the FlexMock::TestCase module in each test case class where you wish
-to use mock objects. FlexMock versions prior to 0.6.0 required the explicit
-include.
+<b>NOTE:</b> If you don't want to automatically extend every TestCase
+with the flexmock methods and overhead, then require the 'flexmock'
+file and explicitly include the FlexMock::TestCase module in each test
+case class where you wish to use mock objects. FlexMock versions prior
+to 0.6.0 required the explicit include.
 
 == RSpec Integration
 
@@ -124,14 +123,15 @@ FlexMock::MockContainer#flexmock for more details.
 
 * <b>mock = flexmock(:foo => :bar, :baz => :froz)</b>
 
-  Create a mock object and define two mocked methods (:foo and :baz) that
-  return the values :bar and :froz respectively. This is useful when creating
-  mock objects with just a few methods and simple return values.
+  Create a mock object and define two mocked methods (:foo and :baz)
+  that return the values :bar and :froz respectively. This is useful
+  when creating mock objects with just a few methods and simple return
+  values.
 
 * <b>mock = flexmock("joe", :foo => :bar, :bar => :froz)</b>
 
-  You can combine the mock name and an expectation hash in the same call to
-  flexmock.
+  You can combine the mock name and an expectation hash in the same
+  call to flexmock.
 
 * <b>mock = flexmock("joe", :on, User)</b>
 
@@ -148,8 +148,8 @@ FlexMock::MockContainer#flexmock for more details.
 
   If you you give <code>flexmock</code> a real object in the argument
   list, it will treat that real object as a base for a partial mock
-  object. The return value <code>m</code> may be used to set
-  expectations. The real_object should be used in the reference
+  object. The return value <code>partial_mock</code> may be used to
+  set expectations. The real_object should be used in the reference
   portion of the test.
 
 * <b>partial_mock = flexmock(real_object, "name", :foo => :baz)</b>
@@ -159,22 +159,23 @@ FlexMock::MockContainer#flexmock for more details.
 * <b>partial_mock = flexmock(:base, real_string_object)</b>
 
   Since Strings (and Symbols for that matter) are used for mock names,
-  FlexMock will not recognize them as the base for a partial mock. To force a
-  string to be used as a partial mock base, proceed the string object in the
-  calling sequence with :base.
+  FlexMock will not recognize them as the base for a partial mock. To
+  force a string to be used as a partial mock base, proceed the string
+  object in the calling sequence with :base.
 
 * <b>partial_mock = flexmock(:safe, real_object) { |mock| mock.should_receive(...) }</b>
 
   When mocking real objects (i.e. "partial mocks"), FlexMock will add
   a handful of mock related methods to the actual object (see below
-  for list of method names).  If one or more of these added methods
-  collide with an existing method on the partial mock, then there are problems.
+  for list of method names). If one or more of these added methods
+  collide with an existing method on the partial mock, then there are
+  problems.
 
   FlexMock offers a "safe" mode for partial mocks that does not add
-  these methods.  Indicate safe mode by passing the symbol :safe as
-  the first argument of flexmock.  A block <em>is required</em> when
-  using safe mode (the partial_mock returned in safe mode does not
-  have a <code>should_receive</code> method).
+  these methods. Indicate safe mode by passing the symbol :safe as the
+  first argument of flexmock. A block <em>is required</em> when using
+  safe mode (the partial_mock returned in safe mode does not have a
+  <code>should_receive</code> method).
 
   The methods added to partial mocks in non-safe mode are:
 
@@ -222,13 +223,14 @@ still available for backward compatibility.
 
 === Expectation Declarators
 
-Once a mock is created, you need to define what that mock should expect to
-see. Expectation declarators are used to specify these expectations placed
-upon received method calls. A basic expectation, created with the
-<code>should_receive</code> method, just establishes the fact that a method may (or may
-not) be called on the mock object. Refinements to that expectation may be
-additionally declared. FlexMock always starts with the most general
-expectation and adds constraints to that.
+Once a mock is created, you need to define what that mock should
+expect to see. Expectation declarators are used to specify these
+expectations placed upon received method calls. A basic expectation,
+created with the <code>should_receive</code> method, just establishes
+the fact that a method may (or may not) be called on the mock object.
+Refinements to that expectation may be additionally declared. FlexMock
+always starts with the most general expectation and adds constraints
+to that.
 
 For example, the following code:
 
@@ -241,8 +243,8 @@ speaking, the <code>and_return</code> part of the declaration isn't
 exactly a constraint, but it does specify what value the mock will
 return when the expectation is matched.
 
-If you want to be more specific, you need to add additional constraints to
-your expectation. Here are some examples:
+If you want to be more specific, you need to add additional
+constraints to your expectation. Here are some examples:
 
     mock.should_receive(:average).with(12).once
 
@@ -250,14 +252,15 @@ your expectation. Here are some examples:
         at_least.twice.at_most.times(10).
         and_return { rand }
 
-The following methods may be used to create and refine expectations on a mock
-object. See theFlexMock::Expectation for more details.
+The following methods may be used to create and refine expectations on
+a mock object. See theFlexMock::Expectation for more details.
 
 * <b>should_receive(<em>method_name</em>)</b>
 
-  Declares that a message named <em>method_name</em> will be sent to the mock
-  object. Constraints on this expected message (called expectations) may be
-  chained to the <code>should_receive</code> call.
+  Declares that a message named <em>method_name</em> will be sent to
+  the mock object. Constraints on this expected message (called
+  expectations) may be chained to the <code>should_receive</code>
+  call.
 
 * <b>should_receive(<em>method_name1</em>, <em>method_name2</em>, ...)</b>
 
@@ -280,9 +283,10 @@ object. See theFlexMock::Expectation for more details.
 
 * <b>should_expect { |<em>recorder</em>| ... }</b>
 
-  Creates a mock recording object that will translate received method calls
-  into mock expectations. The recorder is passed to a block supplied with the
-  <code>should_expect</code> method. See examples below.
+  Creates a mock recording object that will translate received method
+  calls into mock expectations. The recorder is passed to a block
+  supplied with the <code>should_expect</code> method. See examples
+  below.
 
 * <b>with(<em>arglist</em>)</b>
 
@@ -310,8 +314,8 @@ object. See theFlexMock::Expectation for more details.
 
 * <b>once</b>
 
-  Declares that the expected message is only sent once. <tt>at_least</tt> /
-  <tt>at_most</tt> modifiers are allowed.
+  Declares that the expected message is only sent once.
+  <tt>at_least</tt> / <tt>at_most</tt> modifiers are allowed.
 
 * <b>twice</b>
 
@@ -330,25 +334,25 @@ object. See theFlexMock::Expectation for more details.
 
 * <b>at_least</b>
 
-  Modifies the immediately following message count constraint so that it means
-  the message is sent at least that number of times. E.g.
-  <tt>at_least.once</tt> means the message is sent at least once during the
-  test, but may be sent more often. Both <tt>at_least</tt> and
-  <tt>at_most</tt> may be specified on the same expectation.
+  Modifies the immediately following message count constraint so that
+  it means the message is sent at least that number of times. E.g.
+  <tt>at_least.once</tt> means the message is sent at least once
+  during the test, but may be sent more often. Both <tt>at_least</tt>
+  and <tt>at_most</tt> may be specified on the same expectation.
 
 * <b>at_most</b>
 
-  Similar to <tt>at_least</tt>, but puts an upper limit on the number of
-  messages. Both <tt>at_least</tt> and <tt>at_most</tt> may be specified on
-  the same expectation.
+  Similar to <tt>at_least</tt>, but puts an upper limit on the number
+  of messages. Both <tt>at_least</tt> and <tt>at_most</tt> may be
+  specified on the same expectation.
 
 * <b>ordered</b>
 
-  Declares that the expected message is ordered and is expected to be received
-  in a certain position in a sequence of messages. The message should arrive
-  after and previously declared ordered messages and prior to any following
-  declared ordered messages. Unordered messages are ignored when considering
-  the message order.
+  Declares that the expected message is ordered and is expected to be
+  received in a certain position in a sequence of messages. The
+  message should arrive after and previously declared ordered messages
+  and prior to any following declared ordered messages. Unordered
+  messages are ignored when considering the message order.
 
   Normally ordering is performed only against calls in the same mock
   object.  If the "globally" adjective is used, then ordering is
@@ -356,9 +360,10 @@ object. See theFlexMock::Expectation for more details.
 
 * <b>ordered(<em>group</em>)</b>
 
-  Declare that the expected message belongs to an order group. Methods within
-  an order group may be received in any order. Ordered messages outside the
-  group must be received either before or after all of the grouped messages.
+  Declare that the expected message belongs to an order group. Methods
+  within an order group may be received in any order. Ordered messages
+  outside the group must be received either before or after all of the
+  grouped messages.
 
   For example, in the following, messages <code>flip</code> and
   <code>flop</code> may be received in any order (because they are in
@@ -410,17 +415,17 @@ not.
 
 * <b>and_return(<em>value1</em>, <em>value2</em>, ...)</b>
 
-  Declares that the expected message will return a series of values. Each
-  invocation of the message will return the next value in the series. The last
-  value will be repeatably returned if the number of matching calls exceeds
-  the number of values.
+  Declares that the expected message will return a series of values.
+  Each invocation of the message will return the next value in the
+  series. The last value will be repeatably returned if the number of
+  matching calls exceeds the number of values.
 
 * <b>and_return { |<em>args</em>, ...|  <em>code</em> ... } </b>
 
-  Declares that the expected message will return the yielded value of the
-  block. The block will receive all the arguments in the message. If the
-  message was provided a block, it will be passed as the last parameter of the
-  block's argument list.
+  Declares that the expected message will return the yielded value of
+  the block. The block will receive all the arguments in the message.
+  If the message was provided a block, it will be passed as the last
+  parameter of the block's argument list.
 
 * <b>returns( ... )</b>
 
@@ -519,10 +524,11 @@ The following rules are used for argument matching:
       with(3)         will match    f(3)
       with("hello")   will match    f("hello")
 
-* If you wish to override the default matching behavior and force matching by
-  equality, you can use the FlexMock.eq convenience method. This is mostly
-  used when you wish to match class objects, since the default matching
-  behavior for class objects is to match instances, not themselves.
+* If you wish to override the default matching behavior and force
+  matching by equality, you can use the FlexMock.eq convenience
+  method. This is mostly used when you wish to match class objects,
+  since the default matching behavior for class objects is to match
+  instances, not themselves.
 
   Examples:
 
@@ -595,9 +601,9 @@ object. If you pass a real object to the <code>flexmock</code> method,
 it will allow you to use that real object in your test and will just
 mock out the one or two methods that you specify.
 
-For example, suppose that a Dog object uses a Woofer object to bark. The code
-for Dog looks like this (we will leave the code for Woofer to your
-imagination):
+For example, suppose that a Dog object uses a Woofer object to bark.
+The code for Dog looks like this (we will leave the code for Woofer to
+your imagination):
 
   class Dog
     def initialize
@@ -611,9 +617,9 @@ imagination):
     end
   end
 
-Now we want to test Dog, but using a real Woofer object in the test is a real
-pain (why? ... well because Woofer plays a sound file of a dog barking, and
-that's really annoying during testing).
+Now we want to test Dog, but using a real Woofer object in the test is
+a real pain (why? ... well because Woofer plays a sound file of a dog
+barking, and that's really annoying during testing).
 
 So, how can we create a Dog object with mocked Woofer? All we need to
 do is allow FlexMock to replace the <code>bark</code> method.
@@ -636,9 +642,9 @@ Here's the test code:
     end
   end
 
-The nice thing about this technique is that after the test is over, the mocked
-out methods are returned to their normal state. Outside the test everything is
-back to normal.
+The nice thing about this technique is that after the test is over,
+the mocked out methods are returned to their normal state. Outside the
+test everything is back to normal.
 
 <b>NOTE:</b> In previous versions of FlexMock, partial mocking was
 called "stubs" and the <code>flexstub</code> method was used to create
@@ -682,8 +688,8 @@ MiniTest for asserting that mocked methods are actually called.
   section above are allowed in the <code>assert_spy_called</code>
   method.
 
-  The options has is optional. If omitted, all options have their
-  default values.
+  The <code>options</code> hash is optional. If omitted, all options
+  will have their default values.
 
 * <b>assert_spy_not_called <em>mock</em>, <em>options_hash</em>, <em>method_name</em>, <em>args...</em></b>
 

data/Rakefile

@@ -78,16 +78,17 @@ end
 
 # RDoc Target --------------------------------------------------------
 
-task :rdoc => ["html/index.html", :fixcss]
+task :rdoc => ["README.rdoc", "html/index.html", :fixcss]
 
 file "html/index.html" => ["Rakefile"] + RDOC_FILES do
   sh "rdoc -o html --title FlexMock --line-numbers -m README.rdoc #{RDOC_FILES}"
 end
 
 file "README.rdoc" => ["Rakefile", "lib/flexmock/version.rb"] do
-  ruby %{-i.bak -pe '$_.sub!(/^Version *:: *(\\d+\\.)+\\d+ *$/, "Version :: #{PKG_VERSION}")' README.rdoc} # "
+  ruby %{-i.bak -pe '$_.sub!(/^Version *:: *((\\d+|beta|rc)\\.)+\\d+ *$/i, "Version :: #{PKG_VERSION}")' README.rdoc} # "
 end
 
+desc "Fix the Darkfish CSS so that paragraphs in lists have a bit of spacing"
 task :fixcss do
   open("html/rdoc.css") do |ins|
     open("html/rdoc.new", "w") do |outs|

data/doc/releases/flexmock-1.0.0.rdoc

@@ -6,6 +6,8 @@ a few bug fixes.
 
 == Changes in 1.0.0
 
+=== Features
+
 * Mocks may now have a base class that limits what methods may be
   mocked. This allows early detection of outdated mock setups when the
   methods in the class are refactored.
@@ -21,6 +23,12 @@ a few bug fixes.
 * An RSpec matcher (have_received) has been added to make spy
   assertions easy when using RSpec.
 
+=== Bug Fixes
+
+* Now correctly handling the mocking of meta-programmed methods.
+
+* Using the documented +singleton_methods+ method.
+
 == What is FlexMock?
 
 FlexMock is a flexible framework for creating mock object for testing. When

data/lib/flexmock/partial_mock.rb

@@ -207,7 +207,7 @@ class FlexMock
     # Is the given method name a singleton method in the object we are
     # mocking?
     def singleton?(method_name)
-      @obj.methods(false).include?(method_name.to_s)
+      @obj.singleton_methods.include?(method_name.to_s)
     end
 
     # Hide the existing method definition with a singleton defintion
@@ -244,17 +244,24 @@ class FlexMock
     # alias name.  If the aliasing process fails (because the method
     # doesn't really exist, then return nil.
     def create_alias_for_existing_method(method_name)
-      begin
-        new_alias = new_name(method_name)
-        unless @obj.respond_to?(new_alias)
-          sclass.class_eval do
-            alias_method(new_alias, method_name)
-          end
+      new_alias = new_name(method_name)
+      unless @obj.respond_to?(new_alias)
+        safe_alias_method(new_alias, method_name)
+      end
+      new_alias
+    end
+
+    # Create an alias for the existing method named +method_name+. It
+    # is possible that +method_name+ is implemented via a
+    # meta-programming, so we provide for the case that the
+    # method_name does not exist.
+    def safe_alias_method(new_alias, method_name)
+      sclass.class_eval do
+        begin
+          alias_method(new_alias, method_name)
+        rescue NameError => ex
+          nil
         end
-        new_alias
-      rescue NameError => _
-        # Alias attempt failed
-        nil
       end
     end
 
@@ -283,12 +290,17 @@ class FlexMock
     # Restore the original singleton defintion for method_name that
     # was saved earlier.
     def restore_original_definition(method_name)
-      method_def = @method_definitions[method_name]
-      if method_def
-        the_alias = new_name(method_name)
-        sclass.class_eval do
-          alias_method(method_name, the_alias)
+      begin
+        method_def = @method_definitions[method_name]
+        if method_def
+          the_alias = new_name(method_name)
+          sclass.class_eval do
+            alias_method(method_name, the_alias)
+          end
         end
+      rescue NameError => _
+        # Alias attempt failed
+        nil
       end
     end
 

data/lib/flexmock/version.rb

@@ -5,7 +5,7 @@ class FlexMock
       MINOR = 0,
       BUILD = 0,
       BETA = 'beta',
-      REV  = 1,
+      BETAREV = 2,
     ]
   end
 

data/test/partial_mock_test.rb

@@ -269,7 +269,24 @@ class TestStubbing < Test::Unit::TestCase
       assert ! dog.respond_to?(sym), "should not have :#{sym} defined"
     end
   end
-
+  
+  # This test ensures that singleton? does not use the old methods(false)
+  # call that has fallen out of favor in Ruby 1.9. In multiple 1.9 releases
+  # Delegator#methods will not even accept the optional argument, making flexmock
+  # explode. Since there is a way to get singleton methods officially we might
+  # as well just do it, right?
+  class NoMethods
+    def methods(arg = true)
+      raise "Should not be called in the test lifecycle"
+    end
+  end
+  
+  def test_object_methods_method_is_not_used_in_singleton_checks
+    obj = NoMethods.new
+    def obj.mock() :original end
+    assert_nothing_raised {  flexmock(obj) }
+  end
+  
   def test_partial_mocks_with_mock_method_singleton_colision_have_original_defs_restored
     dog = Dog.new
     def dog.mock() :original end
@@ -343,6 +360,25 @@ class TestStubbing < Test::Unit::TestCase
     assert_equal :xyzzy, liar.not_defined
   end
 
+  class MetaDog < Dog
+    def method_missing(method, *args, &block)
+      if method.to_s =~ /meow/
+        :meow
+      else
+        super
+      end
+    end
+    def respond_to_missing?(method, *)
+      method =~ /meow/ || super
+    end
+  end
+
+  def test_partial_mock_where_method_created_by_method_missing_and_respond_to_missing
+    dog = MetaDog.new
+    flexmock(dog, :meow => :hiss)
+    assert_equal :hiss, dog.meow
+  end
+
   # The following test was suggested by Pat Maddox for the RSpec
   # mocks.  Evidently the (poorly implemented) == method caused issues
   # with RSpec Mock's internals.  I'm just double checking for any

metadata

@@ -2,7 +2,7 @@
 name: flexmock
 version: !ruby/object:Gem::Version 
   prerelease: 6
-  version: 1.0.0.beta.1
+  version: 1.0.0.beta.2
 platform: ruby
 authors: 
 - Jim Weirich
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-08-21 00:00:00 Z
+date: 2012-08-22 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    "