minitest 2.2.2 → 2.3.0

data/History.txt

@@ -1,3 +1,18 @@
+=== 2.3.0 / 2011-06-15
+
+* 5 minor enhancements:
+
+  * Add setup and teardown hooks to MiniTest::TestCase. (phiggins)
+  * Added nicer error messages for MiniTest::Mock. (phiggins)
+  * Allow for less specific expected arguments in Mock. (bhenderson/phiggins)
+  * Made MiniTest::Mock a blank slate. (phiggins)
+  * Refactored minitest/spec to use the hooks instead of define_inheritable_method. (phiggins)
+
+* 2 bug fixes:
+
+  * Fixed TestCase's inherited hook. (dchelimsky/phiggins/jamis, the 'good' neighbor)
+  * MiniTest::Assertions#refute_empty should use mu_pp in the default message. (whatthejeff)
+
 === 2.2.2 / 2011-06-01
 
 * 2 bug fixes:

data/lib/minitest/mock.rb

@@ -9,20 +9,37 @@ module MiniTest
   # All mock objects are an instance of Mock
 
   class Mock
+    alias :__respond_to? :respond_to?
+
+    instance_methods.each do |m| 
+      undef_method m unless m =~ /^__|object_id|respond_to_missing?/
+    end
+
     def initialize # :nodoc:
       @expected_calls = {}
       @actual_calls = Hash.new {|h,k| h[k] = [] }
     end
 
     ##
-    # Expect that method +name+ is called, optionally with +args+, and
-    # returns +retval+.
+    # Expect that method +name+ is called, optionally with +args+, and returns
+    # +retval+.
     #
     #   @mock.expect(:meaning_of_life, 42)
     #   @mock.meaning_of_life # => 42
     #
     #   @mock.expect(:do_something_with, true, [some_obj, true])
     #   @mock.do_something_with(some_obj, true) # => true
+    #
+    # +args+ is compared to the expected args using case equality (ie, the
+    # '===' operator), allowing for less specific expectations.
+    #
+    #   @mock.expect(:uses_any_string, true, [String])
+    #   @mock.uses_any_string("foo") # => true
+    #   @mock.verify  # => true
+    #
+    #   @mock.expect(:uses_one_string, true, ["foo"]
+    #   @mock.uses_one_string("bar") # => true
+    #   @mock.verify  # => raises MockExpectationError
 
     def expect(name, retval, args=[])
       @expected_calls[name] = { :retval => retval, :args => args }
@@ -45,17 +62,26 @@ module MiniTest
     end
 
     def method_missing(sym, *args) # :nodoc:
-      raise NoMethodError unless @expected_calls.has_key?(sym)
-      raise ArgumentError unless @expected_calls[sym][:args].size == args.size
+      unless @expected_calls.has_key?(sym)
+        raise NoMethodError, "unmocked method '%s', expected one of %s" % 
+          [sym, @expected_calls.keys.map{|s| "'#{s}'" }.sort.join(", ")]
+      end
+
+      unless @expected_calls[sym][:args].size == args.size
+        raise ArgumentError, "mocked method '%s' expects %d arguments, got %d" %
+          [sym, @expected_calls[sym][:args].size, args.size]
+      end
+
       retval = @expected_calls[sym][:retval]
-      @actual_calls[sym] << { :retval => retval, :args => args }
+      args_case = @expected_calls[sym][:args].
+        each_with_index.map{|a, i| a if a === args[i]}
+      @actual_calls[sym] << { :retval => retval, :args => args_case }
       retval
     end
 
-    alias :original_respond_to? :respond_to?
     def respond_to?(sym) # :nodoc:
       return true if @expected_calls.has_key?(sym)
-      return original_respond_to?(sym)
+      return __respond_to?(sym)
     end
   end
 end

data/lib/minitest/spec.rb

@@ -82,17 +82,8 @@ module Kernel
                           else
                             MiniTest::Spec.spec_type desc
                           end
-    cls   = Class.new sclas
 
-    sclas.children << cls unless cls == MiniTest::Spec
-
-    # :stopdoc:
-    # omg this sucks
-    (class << cls; self; end).send(:define_method, :to_s) { name }
-    (class << cls; self; end).send(:define_method, :desc) { desc }
-    # :startdoc:
-
-    cls.nuke_test_methods!
+    cls = sclas.create(name, desc)
 
     stack.push cls
     cls.class_eval(&block)
@@ -160,25 +151,6 @@ class MiniTest::Spec < MiniTest::Unit::TestCase
     end
   end
 
-  ##
-  # Spec users want setup/teardown to be inherited and NOTHING ELSE.
-  # It is almost like method reuse is lost on them.
-
-  def self.define_inheritable_method name, &block # :nodoc:
-    # regular super() warns
-    super_method = self.superclass.instance_method name
-
-    teardown     = name.to_s == "teardown"
-    super_before = super_method && ! teardown
-    super_after  = super_method && teardown
-
-    define_method name do
-      super_method.bind(self).call if super_before
-      instance_eval(&block)
-      super_method.bind(self).call if super_after
-    end
-  end
-
   ##
   # Define a 'before' action. Inherits the way normal methods should.
   #
@@ -188,7 +160,8 @@ class MiniTest::Spec < MiniTest::Unit::TestCase
 
   def self.before type = :each, &block
     raise "unsupported before type: #{type}" unless type == :each
-    define_inheritable_method :setup, &block
+
+    add_setup_hook {|tc| tc.instance_eval(&block) }
   end
 
   ##
@@ -200,7 +173,8 @@ class MiniTest::Spec < MiniTest::Unit::TestCase
 
   def self.after type = :each, &block
     raise "unsupported after type: #{type}" unless type == :each
-    define_inheritable_method :teardown, &block
+
+    add_teardown_hook {|tc| tc.instance_eval(&block) }
   end
 
   ##
@@ -226,6 +200,29 @@ class MiniTest::Spec < MiniTest::Unit::TestCase
       mod.send :undef_method, name if mod.public_method_defined? name
     end
   end
+
+  def self.create(name, desc) # :nodoc:
+    cls = Class.new(self) do
+      @name = name
+      @desc = desc
+
+      nuke_test_methods!
+    end
+
+    children << cls
+
+    cls
+  end
+
+  def self.to_s # :nodoc:
+    defined?(@name) ? @name : super
+  end
+
+  # :stopdoc:
+  class << self
+    attr_reader :name, :desc
+  end
+  # :startdoc:
 end
 
 Object.infect_with_assertions(:must, :wont,

data/lib/minitest/unit.rb

@@ -485,7 +485,7 @@ module MiniTest
     # Fails if +obj+ is empty.
 
     def refute_empty obj, msg = nil
-      msg = message(msg) { "Expected #{obj.inspect} to not be empty" }
+      msg = message(msg) { "Expected #{mu_pp(obj)} to not be empty" }
       assert_respond_to obj, :empty?
       refute obj.empty?, msg
     end
@@ -614,7 +614,7 @@ module MiniTest
   end
 
   class Unit
-    VERSION = "2.2.2" # :nodoc:
+    VERSION = "2.3.0" # :nodoc:
 
     attr_accessor :report, :failures, :errors, :skips # :nodoc:
     attr_accessor :test_count, :assertion_count       # :nodoc:
@@ -939,6 +939,7 @@ module MiniTest
         begin
           @passed = nil
           self.setup
+          self.run_setup_hooks
           self.__send__ self.__name__
           result = "." unless io?
           @passed = true
@@ -949,6 +950,7 @@ module MiniTest
           result = runner.puke self.class, self.__name__, e
         ensure
           begin
+            self.run_teardown_hooks
             self.teardown
           rescue *PASSTHROUGH_EXCEPTIONS
             raise
@@ -983,6 +985,8 @@ module MiniTest
 
       def self.inherited klass # :nodoc:
         @@test_suites[klass] = true
+        klass.reset_setup_teardown_hooks
+        super
       end
 
       ##
@@ -1029,6 +1033,111 @@ module MiniTest
 
       def teardown; end
 
+      def self.reset_setup_teardown_hooks # :nodoc:
+        @setup_hooks = []
+        @teardown_hooks = []
+      end
+
+      reset_setup_teardown_hooks
+
+      ##
+      # Adds a block of code that will be executed before every TestCase is
+      # run. Equivalent to +setup+, but usable multiple times and without
+      # re-opening any classes.
+      #
+      # All of the setup hooks will run in order after the +setup+ method, if
+      # one is defined.
+      #
+      # The argument can be any object that responds to #call or a block.
+      # That means that this call,
+      #
+      #     MiniTest::TestCase.add_setup_hook { puts "foo" }
+      #
+      # ... is equivalent to:
+      #
+      #     module MyTestSetup
+      #       def call
+      #         puts "foo"
+      #       end
+      #     end
+      #
+      #     MiniTest::TestCase.add_setup_hook MyTestSetup
+      #
+      # The blocks passed to +add_setup_hook+ take an optional parameter that
+      # will be the TestCase instance that is executing the block.
+
+      def self.add_setup_hook arg=nil, &block
+        hook = arg || block
+        @setup_hooks << hook
+      end
+
+      def self.setup_hooks # :nodoc:
+        if superclass.respond_to? :setup_hooks then
+          superclass.setup_hooks
+        else
+          []
+        end + @setup_hooks
+      end
+
+      def run_setup_hooks # :nodoc:
+        self.class.setup_hooks.each do |hook|
+          if hook.respond_to?(:arity) && hook.arity == 1
+            hook.call(self)
+          else
+            hook.call
+          end
+        end
+      end
+
+      ##
+      # Adds a block of code that will be executed after every TestCase is
+      # run. Equivalent to +teardown+, but usable multiple times and without
+      # re-opening any classes.
+      #
+      # All of the teardown hooks will run in reverse order after the
+      # +teardown+ method, if one is defined.
+      #
+      # The argument can be any object that responds to #call or a block.
+      # That means that this call,
+      #
+      #     MiniTest::TestCase.add_teardown_hook { puts "foo" }
+      #
+      # ... is equivalent to:
+      #
+      #     module MyTestTeardown
+      #       def call
+      #         puts "foo"
+      #       end
+      #     end
+      #
+      #     MiniTest::TestCase.add_teardown_hook MyTestTeardown
+      #
+      # The blocks passed to +add_teardown_hook+ take an optional parameter
+      # that will be the TestCase instance that is executing the block.
+
+      def self.add_teardown_hook arg=nil, &block
+        hook = arg || block
+        @teardown_hooks << hook
+      end
+
+      def self.teardown_hooks # :nodoc:
+        if superclass.respond_to? :teardown_hooks then
+          superclass.teardown_hooks
+        else
+          []
+        end + @teardown_hooks
+      end
+
+      def run_teardown_hooks # :nodoc:
+        self.class.teardown_hooks.reverse.each do |hook|
+          if hook.respond_to?(:arity) && hook.arity == 1
+            hook.call(self)
+          else
+            hook.call
+          end
+        end
+      end
+
       include MiniTest::Assertions
     end # class TestCase
   end # class Unit

data/test/test_minitest_mock.rb

@@ -43,20 +43,16 @@ class TestMiniTestMock < MiniTest::Unit::TestCase
     util_verify_bad
   end
 
-  def test_not_verify_if_unexpected_method_is_called
-    assert_raises NoMethodError do
-      @mock.unexpected
-    end
-  end
-
   def test_blow_up_on_wrong_number_of_arguments
     @mock.foo
     @mock.meaning_of_life
     @mock.expect(:sum, 3, [1, 2])
 
-    assert_raises ArgumentError do
+    e = assert_raises ArgumentError do
       @mock.sum
     end
+
+    assert_equal "mocked method 'sum' expects 2 arguments, got 0", e.message
   end
 
   def test_blow_up_on_wrong_arguments
@@ -75,9 +71,13 @@ class TestMiniTestMock < MiniTest::Unit::TestCase
   end
 
   def test_no_method_error_on_unexpected_methods
-    assert_raises NoMethodError do
+    e = assert_raises NoMethodError do
       @mock.bar
     end
+
+    expected = "unmocked method 'bar', expected one of 'foo', 'meaning_of_life'"
+
+    assert_equal expected, e.message
   end
 
   def test_assign_per_mock_return_values
@@ -98,6 +98,30 @@ class TestMiniTestMock < MiniTest::Unit::TestCase
     assert !MiniTest::Mock.new.respond_to?(:foo)
   end
 
+  def test_mock_is_a_blank_slate
+    @mock.expect :kind_of?, true, [Fixnum]
+    @mock.expect :==, true, [1]
+
+    assert @mock.kind_of?(Fixnum), "didn't mock :kind_of?"
+    assert @mock == 1, "didn't mock :=="
+  end
+
+  def test_verify_allows_called_args_to_be_loosely_specified
+    mock = MiniTest::Mock.new
+    mock.expect :loose_expectation, true, [Integer]
+    mock.loose_expectation 1
+
+    assert mock.verify
+  end
+
+  def test_verify_raises_with_strict_args
+    mock = MiniTest::Mock.new
+    mock.expect :strict_expectation, true, [2]
+    mock.strict_expectation 1
+
+    util_verify_bad
+  end
+
   def util_verify_bad
     assert_raises MockExpectationError do
       @mock.verify

data/test/test_minitest_spec.rb

@@ -239,8 +239,8 @@ class TestMeta < MiniTest::Unit::TestCase
     assert_equal "inner thingy", y.desc
     assert_equal "very inner thingy", z.desc
 
-    top_methods = %w(setup teardown test_0001_top_level_it)
-    inner_methods = %w(setup teardown test_0001_inner_it)
+    top_methods = %w(test_0001_top_level_it)
+    inner_methods = %w(test_0001_inner_it)
 
     assert_equal top_methods,   x.instance_methods(false).sort.map {|o| o.to_s }
     assert_equal inner_methods, y.instance_methods(false).sort.map {|o| o.to_s }
@@ -251,8 +251,9 @@ class TestMeta < MiniTest::Unit::TestCase
     _, _, z, before_list, after_list = util_structure
 
     tc = z.new(nil)
-    tc.setup
-    tc.teardown
+
+    tc.run_setup_hooks
+    tc.run_teardown_hooks
 
     assert_equal [1, 2, 3], before_list
     assert_equal [3, 2, 1], after_list

data/test/test_minitest_unit.rb

@@ -436,6 +436,149 @@ Finished tests in 0.00
     assert_report expected
   end
 
+  def with_overridden_include
+    Class.class_eval do
+      def inherited_with_hacks klass
+        throw :inherited_hook
+      end
+
+      alias inherited_without_hacks inherited
+      alias inherited               inherited_with_hacks
+      alias IGNORE_ME!              inherited # 1.8 bug. god I love venture bros
+    end
+
+    yield
+
+  ensure
+    Class.class_eval do
+      alias inherited inherited_without_hacks
+
+      undef_method :inherited_with_hacks
+      undef_method :inherited_without_hacks
+    end
+
+    refute_respond_to Class, :inherited_with_hacks
+    refute_respond_to Class, :inherited_without_hacks
+  end
+
+  def test_inherited_hook_plays_nice_with_others
+    with_overridden_include do
+      assert_throws :inherited_hook do
+        Class.new MiniTest::Unit::TestCase
+      end
+    end
+  end
+
+  def test_setup_hooks
+    call_order = []
+
+    tc = Class.new(MiniTest::Unit::TestCase) do
+      define_method :setup do
+        super()
+        call_order << :method
+      end
+
+      define_method :test2 do
+        call_order << :test2
+      end
+
+      define_method :test1 do
+        call_order << :test1
+      end
+    end
+
+    tc.add_setup_hook lambda { call_order << :proc }
+
+    argument = nil
+
+    tc.add_setup_hook do |arg|
+      argument = arg
+      call_order << :block
+    end
+
+    @tu.run %w[--seed 42]
+
+    assert_kind_of tc, argument
+
+    expected = [:method, :proc, :block, :test1,
+                :method, :proc, :block, :test2]
+
+    assert_equal expected, call_order
+  end
+
+  def test_teardown_hooks
+    call_order = []
+
+    tc = Class.new(MiniTest::Unit::TestCase) do
+      define_method :teardown do
+        super()
+        call_order << :method
+      end
+
+      define_method :test2 do
+        call_order << :test2
+      end
+
+      define_method :test1 do
+        call_order << :test1
+      end
+    end
+
+    tc.add_teardown_hook lambda { call_order << :proc }
+
+    argument = nil
+
+    tc.add_teardown_hook do |arg|
+      argument = arg
+      call_order << :block
+    end
+
+    @tu.run %w[--seed 42]
+
+    assert_kind_of tc, argument
+
+    expected = [:test1, :block, :proc, :method,
+                :test2, :block, :proc, :method]
+
+    assert_equal expected, call_order
+  end
+
+  def test_setup_and_teardown_hooks_survive_inheritance
+    call_order = []
+
+    parent = Class.new(MiniTest::Unit::TestCase) do
+      define_method :setup do
+        super()
+        call_order << :setup_method
+      end
+
+      define_method :teardown do
+        super()
+        call_order << :teardown_method
+      end
+
+      define_method :test_something do
+        call_order << :test
+      end
+    end
+
+    parent.add_setup_hook     { call_order << :setup_hook }
+    parent.add_teardown_hook  { call_order << :teardown_hook }
+
+    _ = Class.new parent
+
+    parent.add_setup_hook     { call_order << :setup_after }
+    parent.add_teardown_hook  { call_order << :teardown_after }
+
+    @tu.run %w[--seed 42]
+
+    # Once for the parent class, once for the child
+    expected = [:setup_method, :setup_hook, :setup_after, :test,
+                :teardown_after, :teardown_hook, :teardown_method] * 2
+
+    assert_equal expected, call_order
+  end
+
   def util_expand_bt bt
     if RUBY_VERSION =~ /^1\.9/ then
       bt.map { |f| (f =~ /^\./) ? File.expand_path(f) : f }

metadata

@@ -5,9 +5,9 @@ version: !ruby/object:Gem::Version
   prerelease: 
   segments: 
   - 2
-  - 2
-  - 2
-  version: 2.2.2
+  - 3
+  - 0
+  version: 2.3.0
 platform: ruby
 authors: 
 - Ryan Davis
@@ -36,7 +36,7 @@ cert_chain:
   FBHgymkyj/AOSqKRIpXPhjC6
   -----END CERTIFICATE-----
 
-date: 2011-06-01 00:00:00 Z
+date: 2011-06-18 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: minitest

metadata.gz.sig

@@ -1 +1 @@
-[z����@J�䀫:�]��}:{U\Vq��vYW�Pm��`�T@��䟩5��~��N��xlXAfϹt�<�ak��J��֥������@1��!����{��O+�?�1ךL`�z�g�dž�G3a
+{!��v(�ӒhGA�r꺤��D^���7�	�Teؠ�݈^�>H~eTF0D���OQ��m�A�=��93:#[: