flexmock 1.3.0 → 1.3.1

data/doc/index.rdoc

@@ -4,7 +4,7 @@ FlexMock is a simple, but flexible, mock object library for Ruby unit
 testing.
 
 This is the API documentation site for flexmock. You can find the user
-documentation at http://github.com/jimweirich/flexmock.
+documentation at http://github.com/jimweirich/flexmock
 
 == Links
 

data/doc/releases/flexmock-1.3.1.rdoc

@@ -0,0 +1,171 @@
+= FlexMock 1.3.1 Released
+
+FlexMock is a flexible mocking library for use in unit testing and
+behavior specification in Ruby. This release is a minor release with a
+few bug fixes and some simple features.
+
+== Changes in 1.3.1
+
+* Removed use of assert_block (which is deprecated in MiniTest).
+
+* Documentation fixes.
+
+== Changes in 1.3.0
+
+=== Features
+
+* Add 'and' and 'on' modifiers for the RSpec spy matcher.
+
+* Add 'and' and 'on' options to the assert_spy_called test method.
+
+* General documentation improvement.
+
+=== Bug Fixes
+
+* Fix bug in should_fail test helper that was not detecting failed
+  failures.
+
+== Changes in 1.2.0
+
+=== Features
+
+* Add auto configure by requiring 'flexmock/rspec/configure'.
+
+== Changes in 1.1.0
+
+=== Features
+
+* Add block support to pass_thru.
+
+== 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.
+
+* Spy assertions are now allowed. The verification of the calling of
+  mocked methods may now be done in the "then" portion of the test,
+  after the code under test has been run. This allows for much more
+  natural Given/When/Then style testing.
+
+* A custom assert method (assert_spy_called) has been added to make
+  spy assertions easy when using Test::Unit or MiniTest.
+
+* 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.
+
+* 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 running unit tests, it is often desirable to use isolate the
+objects being tested from the "real world" by having them interact
+with simplified test objects. Sometimes these test objects simply
+return values when called, other times they verify that certain
+methods were called with particular arguments in a particular order.
+
+FlexMock makes creating these test objects easy.
+
+=== Features
+
+* Easy integration with both Test::Unit and RSpec. Mocks created with the
+  flexmock method are automatically verified at the end of the test or
+  example.
+
+* A fluent interface that allows mock behavior to be specified very
+  easily.
+
+* A "record mode" where an existing implementation can record its
+  interaction with a mock for later validation against a new
+  implementation.
+
+* Easy mocking of individual methods in existing, non-mock objects.
+
+* Easy mocking of chains of method calls.
+
+* The ability to cause classes to instantiate test instances (instead of real
+  instances) for the duration of a test.
+
+=== Example
+
+Suppose you had a Dog object that wagged a tail when it was happy.
+Something like this:
+
+  class Dog
+    def initialize(a_tail)
+      @tail = a_tail
+    end
+    def happy
+      @tail.wag
+    end
+  end
+
+To test the +Dog+ class without a real +Tail+ object (perhaps because
+real +Tail+ objects activate servos in some robotic equipment), you
+can do something like this:
+
+  RSpec.configure do |config|
+    config.mock_with :flexmock
+  end
+
+  describe Dog do
+    it "wags its tail when happy" do
+      tail = flexmock("tail")
+      tail.should_receive(:wag).once
+      dog = Dog.new(tail)
+      dog.happy
+    end
+  end
+
+FlexMock will automatically verify that the mocked tail object received the
+message +wag+ exactly one time. If it doesn't, the test will not pass.
+
+Here's the same thing using the new spy support:
+
+  describe Dog do
+    it "wags its tail when happy" do
+      tail = flexmock("tail")
+      dog = Dog.new(tail)
+      dog.happy
+      tail.should have_received(:wag)
+    end
+  end
+
+This style works particularly well with the rspec-given library.
+
+  require 'rspec/given'
+
+  describe Dog do
+    context "when the dog is happy" do
+      Given(:tail) { flexmock(:on, Tail) }
+      Given(:dog) { Dog.new(tail) }
+
+      When { dog.happy }
+
+      Then { tail.should have_received(:wag) }
+    end
+  end
+
+See the FlexMock documentation at http://flexmock.rubyforge.org for details on
+specifying arguments and return values on mocked methods, as well as a simple
+technique for mocking tail objects when the Dog class creates the tail objects
+directly.
+
+== Availability
+
+You can make sure you have the latest version with a quick RubyGems command:
+
+  gem install flexmock    (you may need root/admin privileges)
+
+You will find documentation at: http://flexmock.rubyforge.org.
+
+-- Jim Weirich

data/lib/flexmock/core.rb

@@ -52,6 +52,11 @@ class FlexMock
   attr_reader :flexmock_name
   attr_accessor :flexmock_container
 
+  class << self
+    attr_accessor :partials_are_based
+  end
+  self.partials_are_based = false
+
   # Create a FlexMock object with the given name.  The name is used in
   # error messages.  If no container is given, create a new, one-off
   # container for this mock.

data/lib/flexmock/core_class_methods.rb

@@ -67,7 +67,7 @@ class FlexMock
     # Check will assert the block returns true.  If it doesn't, an
     # assertion failure is triggered with the given message.
     def check(msg, &block)  # :nodoc:
-      FlexMock.framework_adapter.assert_block(msg, &block)
+      FlexMock.framework_adapter.make_assertion(msg, &block)
     end
 
   end

data/lib/flexmock/default_framework_adapter.rb

@@ -13,7 +13,7 @@ require 'flexmock/noop'
 
 class FlexMock
   class DefaultFrameworkAdapter
-    def assert_block(msg, &block)
+    def make_assertion(msg, &block)
       unless yield
         msg = msg.call if msg.is_a?(Proc)
         fail assertion_failed_error, msg
@@ -21,7 +21,7 @@ class FlexMock
     end
 
     def assert_equal(a, b, msg=nil)
-      assert_block(msg || "Expected equal") { a == b }
+      make_assertion(msg || "Expected equal") { a == b }
     end
 
     class AssertionFailedError < StandardError; end

data/lib/flexmock/explicit_needed.rb

@@ -5,7 +5,7 @@ class FlexMock
   # methods supported by the base class. Attempting to add an stub to
   # a method not defined on the base class will cause the expectation
   # to be wrapped in an ExplicitNeeded wrapper. The wrapper will throw
-  # an exception unless the explicit method is immediately called on
+  # an exception unless the explicitly method is immediately called on
   # the expectation.
   #
   class ExplicitNeeded
@@ -25,6 +25,10 @@ class FlexMock
       @explicit
     end
 
+    def mock=(m)
+      @expectation.mock = m
+    end
+
     def method_missing(sym, *args, &block)
       if explicit?
         @expectation.send(sym, *args, &block)

data/lib/flexmock/mock_container.rb

@@ -160,7 +160,11 @@ class FlexMock
         mock ||= FlexMock.new(name || "unknown", self)
         result = mock
       end
-      mock.flexmock_based_on(base_class) if base_class
+      if base_class
+        mock.flexmock_based_on(base_class)
+      elsif domain_obj && FlexMock.partials_are_based
+        mock.flexmock_based_on(domain_obj.class)
+      end
       mock.flexmock_define_expectation(location, quick_defs)
       yield(mock) if block_given?
       flexmock_remember(mock)

data/lib/flexmock/partial_mock.rb

@@ -205,6 +205,11 @@ class FlexMock
       @mock.flexmock_expectations_for(method_name)
     end
 
+    # Forward the based on request.
+    def flexmock_based_on(*args)
+      @mock.flexmock_based_on(*args)
+    end
+
     private
 
     def check_allocate_method(allocate_method)

data/lib/flexmock/rspec.rb

@@ -21,14 +21,14 @@ class FlexMock
   end
 
   class RSpecFrameworkAdapter
-    def assert_block(msg, &block)
+    def make_assertion(msg, &block)
       msg = msg.call if msg.is_a?(Proc)
       SpecModule::Expectations.fail_with(msg) unless yield
     end
 
     def assert_equal(a, b, msg=nil)
       message = msg || "Expected equal"
-      assert_block(message + "\n<#{a}> expected, but was\n<#{b}>") { a == b }
+      make_assertion(message + "\n<#{a}> expected, but was\n<#{b}>") { a == b }
     end
 
     class AssertionFailedError < StandardError; end

data/lib/flexmock/test_unit_integration.rb

@@ -9,7 +9,7 @@
 # above copyright notice is included.
 #+++
 
-require 'test/unit'
+require 'test/unit/assertions'
 require 'flexmock/base'
 require 'flexmock/test_unit_assert_spy_called'
 
@@ -47,10 +47,10 @@ class FlexMock
   class TestUnitFrameworkAdapter
     include Test::Unit::Assertions
 
-    def assert_block(msg, &block)
+    def make_assertion(msg, &block)
       unless yield
         msg = msg.call if msg.is_a?(Proc)
-        super(msg) { false }
+        assert(false, msg)
       end
     rescue assertion_failed_error => ex
       ex.message.sub!(/Expected block to return true value./,'')

data/lib/flexmock/validators.rb

@@ -50,6 +50,22 @@ class FlexMock
         ".times(#{@limit})"
       end
     end
+
+    def describe_limit
+      @limit.to_s
+    end
+
+    def validate_count(n, &block)
+      @exp.flexmock_location_filter do
+        FlexMock.framework_adapter.make_assertion(
+          lambda {
+            "Method '#{@exp}' called incorrect number of times\n" +
+            "#{describe_limit} matching #{calls(@limit)} expected\n" +
+            "#{n} matching #{calls(n)} found\n" +
+            describe_calls(@exp.mock)
+          }, &block)
+      end
+    end
   end
 
   ####################################################################
@@ -59,16 +75,7 @@ class FlexMock
     # Validate that the method expectation was called exactly +n+
     # times.
     def validate(n)
-      @exp.flexmock_location_filter do
-        FlexMock.framework_adapter.assert_block(
-          lambda {
-            "Method '#{@exp}' called incorrect number of times\n" +
-            "#{@limit} matching #{calls(@limit)} expected\n" +
-            "#{n} matching #{calls(n)} found\n" +
-            describe_calls(@exp.mock)
-          }
-          ) { @limit == n }
-      end
+      validate_count(n) { @limit == n }
     end
   end
 
@@ -79,15 +86,7 @@ class FlexMock
     # Validate the method expectation was called no more than +n+
     # times.
     def validate(n)
-      @exp.flexmock_location_filter do
-        FlexMock.framework_adapter.assert_block(
-          lambda {
-            "Method '#{@exp}' called incorrect number of times\n" +
-            "At least #{@limit} matching #{calls(@limit)} expected\n" +
-            "#{n} matching #{calls(n)} found\n" +
-            describe_calls(@exp.mock)
-          }) { n >= @limit }
-      end
+      validate_count(n) { n >= @limit }
     end
 
     # Human readable description of the validator.
@@ -106,6 +105,10 @@ class FlexMock
     def eligible?(n)
       true
     end
+
+    def describe_limit
+      "At least #{@limit}"
+    end
   end
 
   ####################################################################
@@ -114,15 +117,7 @@ class FlexMock
   class AtMostCountValidator < CountValidator
     # Validate the method expectation was called at least +n+ times.
     def validate(n)
-      @exp.flexmock_location_filter do
-        FlexMock.framework_adapter.assert_block(
-          lambda {
-            "Method '#{@exp}' called incorrect number of times\n" +
-            "At most #{@limit} matching #{calls(@limit)} expected\n" +
-            "#{n} matching #{calls(n)} found\n" +
-            describe_calls(@exp.mock)
-          }) { n <= @limit }
-      end
+      validate_count(n) { n <= @limit }
     end
 
     # Human readable description of the validator
@@ -130,5 +125,8 @@ class FlexMock
       ".at_most#{super}"
     end
 
+    def describe_limit
+      "At most #{@limit}"
+    end
   end
 end

data/lib/flexmock/version.rb

@@ -3,7 +3,7 @@ class FlexMock
     NUMBERS = [
       MAJOR = 1,
       MINOR = 3,
-      BUILD = 0,
+      BUILD = 1,
     ]
   end
 

data/test/aliasing_test.rb

@@ -2,58 +2,65 @@
 
 require 'test/test_setup'
 
-class FlexMock
-  module StubsAndExpects
-    def expects(*args)
-      result = should_receive(*args)
-      result.at_least.once unless result.call_count_constrained?
-      result
-    end
-    def stubs(*args)
-      should_receive(*args)
-    end
-  end
+# This is an experimental test to see if mock and stub methods can
+# easily be added to a flexmock core. These test are disabled by
+# default, and should be reviewed before something more production
+# oriented is provided.
 
-  module MockContainer
-    alias :mock :flexmock
-    alias :stub :flexmock
-  end
+if ENV['TEST_ALIASES']
+
+  class FlexMock
+    module StubsAndExpects
+      def expects(*args)
+        result = should_receive(*args)
+        result.at_least.once unless result.call_count_constrained?
+        result
+      end
+      def stubs(*args)
+        should_receive(*args)
+      end
+    end
 
-  include StubsAndExpects
+    module MockContainer
+      alias :mock :flexmock
+      alias :stub :flexmock
+    end
 
-  class PartialMockProxy
     include StubsAndExpects
-    MOCK_METHODS << :stubs << :expects
+
+    class PartialMockProxy
+      include StubsAndExpects
+      MOCK_METHODS << :stubs << :expects
+    end
   end
-end
 
-class AliasingTest < Test::Unit::TestCase
-  include FlexMock::TestCase
+  class AliasingTest < Test::Unit::TestCase
+    include FlexMock::TestCase
 
-  def test_mocking
-    m = mock("a cute dog").expects(:pat).twice.and_return(:woof!).mock
-    assert_equal :woof!, m.pat
-    assert_equal :woof!, m.pat
-  end
+    def test_mocking
+      m = mock("a cute dog").expects(:pat).twice.and_return(:woof!).mock
+      assert_equal :woof!, m.pat
+      assert_equal :woof!, m.pat
+    end
 
-  def test_once_mocking
-    mock("a cute dog").expects(:pat).and_return(:woof!).mock
-  end
+    def test_once_mocking
+      mock("a cute dog").expects(:pat).and_return(:woof!).mock
+    end
 
-  def test_twice_mocking
-    m = mock("a cute dog").expects(:pat).and_return(:woof!).twice.mock
-    assert_raises(assertion_failed_error) { m.flexmock_verify }
-  end
+    def test_twice_mocking
+      m = mock("a cute dog").expects(:pat).and_return(:woof!).twice.mock
+      assert_raises(assertion_failed_error) { m.flexmock_verify }
+    end
 
-  def test_stubbing
-    m = stub("a cute dog").expects(:pat).and_return(:woof!).mock
-    assert_equal :woof!, m.pat
-  end
+    def test_stubbing
+      m = stub("a cute dog").expects(:pat).and_return(:woof!).mock
+      assert_equal :woof!, m.pat
+    end
 
-  def test_partial
-    obj = Object.new
-    stub(obj).stubs(:wag).and_return(:tail)
-    assert_equal :tail, obj.wag
+    def test_partial
+      obj = Object.new
+      stub(obj).stubs(:wag).and_return(:tail)
+      assert_equal :tail, obj.wag
+    end
   end
 end
-