miniunit 1.1.0 → 1.2.0

data/lib/test/unit.rb

@@ -1,304 +1,21 @@
-#
-# Totally minimal (hopefully) drop-in replacement for test/unit
-#
+require 'mini/test'
 
-# Minimal methods needed to run full miniunit + assert:
-#
-# Array: each, grep, join, size
-# Class: new, inherited
-# Enumerable: find
-# Exception: backtrace, message
-# Fixnum: +
-# Hash: keys
-# Kernel: at_exit
-# Module: ===, public_instance_methods
-# Object: __send__, class, inspect
-# String: sub, %
-# Regexp: =~
-
-# Only needed for specific assertions:
-#
-# Array.last
-# Enumerable.include?
-# Float: abs
-# Object: ==, inspect, equal?, kind_of?, nil?, respond_to?
-# Numeric: to_f, <, -
-
-$TESTING_MINIUNIT ||= false
-
-at_exit { exit MiniTest::Unit.autotest } unless $TESTING_MINIUNIT
-
-MINIUNIT_FILE_SEPARATORS = %r{[\\/:]}
-MINIUNIT_PREFIX = __FILE__.split(MINIUNIT_FILE_SEPARATORS)[0..-3]
-MINIUNIT_RB_FILE = /\.rb\Z/
-
-def filter_backtrace(backtrace, prefix=nil)
-  return ["No backtrace"] unless(backtrace)
-  return backtrace if $TESTING_MINIUNIT
-  split_p = if(prefix)
-              prefix.split(MINIUNIT_FILE_SEPARATORS)
-            else
-              MINIUNIT_PREFIX
-            end
-  match = proc do |e|
-    split_e = e.split(MINIUNIT_FILE_SEPARATORS)[0, split_p.size]
-    next false unless(split_e[0..-2] == split_p[0..-2])
-    split_e[-1].sub(MINIUNIT_RB_FILE, '') == split_p[-1]
-  end
-  return backtrace unless(backtrace.detect(&match))
-  found_prefix = false
-  new_backtrace = backtrace.reverse.reject do |e|
-    if(match[e])
-      found_prefix = true
-      true
-    elsif(found_prefix)
-      false
-    else
-      true
-    end
-  end.reverse
-  new_backtrace = (new_backtrace.empty? ? backtrace : new_backtrace)
-  new_backtrace = new_backtrace.reject(&match)
-  new_backtrace.empty? ? backtrace : new_backtrace
-end
-
-module MiniTest
-  class Assertion < Exception; end
-
-  class Unit
-    VERSION = "1.1.0"
-
-    attr_reader :report
-
-    @@out = $stdout
-
-    def self.output= stream
-      @@out = stream
-    end
-
-    def self.autotest
-      self.new.autotest
-    end
-
-    def self.tests_from(klass)
-      klass.public_instance_methods(true).grep(/^test/).sort
+module Test
+  module Unit # was ::Mini::Test, but rails' horrid code forced my hand
+    if defined? TestCase then
+      warn "ARGH! someone defined Test::Unit::TestCase rather than requiring"
+      remove_const :TestCase
     end
 
-    def self.location_of_failure(e)
-      e.backtrace.find { |s|
-        s !~ /in .(assert|flunk)/
-      }.sub(/:in .*$/, '')
-    end
-
-    def puke(klass, meth, e)
-      if MiniTest::Assertion === e then
-        @results[:failures] += 1
-        loc = self.class.location_of_failure(e)
-        @report << "Failure:\n#{meth}(#{klass}) [#{loc}]:\n#{e.message}\n"
-        'F'
-      else
-        @results[:errors] += 1
-        bt = filter_backtrace(e.backtrace).join("\n    ")
-        @report << "Error:\n#{meth}(#{klass}):\n#{e.class}: #{e.message}\n    #{bt}\n"
-        'E'
-      end
-    end
-
-    def initialize
-      @report = []
-      @results = {:errors => 0, :failures => 0}
-    end
-
-    def autotest
-      @@out.puts "Loaded suite #{$0.sub(/\.rb$/, '')}\nStarted"
-
-      timestamp_before_test_run = Time.now
-      test_count, assertion_count = run_test_suites
-
-      @@out.puts
-      @@out.puts "Finished in #{'%.6f' % (Time.now - timestamp_before_test_run)} seconds."
-
-      @report.each_with_index do |msg, i|
-        @@out.puts "\n%3d) %s" % [i + 1, msg]
-      end
-
-      @@out.puts
-      @@out.puts "%d tests, %d assertions, %d failures, %d errors" % [test_count, assertion_count, failures, errors]
-
-      return failures + errors
-    end
-
-    def run_test_suites
-      test_count, assertion_count = 0, 0
-      TestCase.test_suites.each do |klass|
-        inst = klass.new
-        inst._assertions = 0
-        tests = self.class.tests_from(klass)
-        tests.each do |meth|
-          result = '.'
-          begin
-            inst.setup
-            inst.__send__ meth
-          rescue Exception => e
-            result = puke(klass, meth, e)
-          ensure
-            begin
-              inst.teardown
-            rescue Exception => e
-              result = puke(klass, meth, e)
-            end
-          end
-          @@out.print result
-        end
-        test_count += tests.size
-        assertion_count += inst._assertions
-      end
-      [test_count, assertion_count]
-    end
-
-    def failures
-      @results[:failures]
-    end
-
-    def errors
-      @results[:errors]
-    end
+    TestCase             = ::Mini::Test::TestCase
+    AssertionFailedError = ::Mini::Assertion
 
     class TestCase
-      def self.reset
-        @@test_suites = {}
-      end
-
-      reset
-
-      def self.inherited klass
-        @@test_suites[klass] = true
-      end
-
-      def self.test_suites
-        @@test_suites.keys.sort_by { |ts| ts.name }
-      end
-
-      attr_accessor :_assertions
-      def setup; end
-      def teardown; end
-
-      def _increment_assertions
-        @_assertions ||= 0
-        @_assertions += 1
-      end
-
-      def assert test, msg = "failed assertion (no message given)"
-        _increment_assertions
-        raise MiniTest::Assertion, msg unless test
-      end
-
-      def assert_block msg = "assert_block failed."
-        assert yield, msg
-      end
-
-      def assert_equal exp, act, msg = ""
-        msg += '.' unless msg.empty?
-        assert exp == act, "#{msg}\n<#{exp.inspect}> expected but was\n<#{act.inspect}>.".strip
-      end
-
-      def assert_in_delta exp, act, delta, msg = "Expected #{exp} to be within #{delta} of #{act}"
-        assert delta.to_f > (exp.to_f - act.to_f).abs, msg
-      end
-
-      def assert_instance_of cls, obj, msg = "Expected #{obj.inspect} to be an instance of #{cls}"
-        assert cls === obj, msg
-      end
-
-      def assert_kind_of cls, obj, msg = "Expected #{obj.inspect} to be a kind of #{cls}"
-        assert obj.kind_of?(cls), msg
-      end
-
-      def assert_match exp, act, msg = "Expected #{act.inspect} to match #{exp.inspect}"
-        assert act =~ exp, msg
-      end
-
-      def assert_nil obj, msg = "Expected #{obj.inspect} to be nil"
-        assert obj.nil?, msg
-      end
-
-      def assert_no_match exp, act, msg = "Expected #{act.inspect} to not match #{exp.inspect}"
-        assert act !~ exp, msg
-      end
-
-      def assert_not_equal exp, act, msg = "Expected #{act.inspect} to not be equal to #{exp.inspect}"
-        assert exp != act, msg
-       end
-
-      def assert_not_nil obj, msg = "Expected #{obj.inspect} to not be nil"
-        assert ! obj.nil?, msg
-      end
-
-      def assert_not_same exp, act, msg = "Expected #{act.inspect} to not be the same as #{exp.inspect}"
-        assert ! exp.equal?(act), msg
-      end
-
-      def assert_nothing_raised
-        _increment_assertions
-        yield
-      rescue => e
-        raise MiniTest::Assertion, exception_details(e, "Exception raised:")
-      end
-
-      alias :assert_nothing_thrown :assert_nothing_raised
-
-      def assert_operator o1, op, o2, msg = "<#{o1.inspect}> expected to be\n#{op.inspect}\n<#{o2.inspect}>."
-        assert o1.__send__(op, o2), msg
-      end
-
-      def exception_details e, msg
-        "#{msg}\nClass: <#{e.class}>\nMessage: <#{e.message.inspect}>\n---Backtrace---\n#{filter_backtrace(e.backtrace).join("\n")}\n---------------"
-      end
-
-      def assert_raises *exp
-        msg = String === exp.last ? exp.pop : nil
-        exp = exp.first if exp.size == 1
-        begin
-          yield
-          raise MiniTest::Assertion, "<#{exp.inspect}> exception expected but none was thrown."
-        rescue Exception => e
-          assert((Array === exp ? exp.include?(e) : exp === e),
-                 exception_details(e,
-                                   "<#{exp.inspect}> exception expected but was"))
-
-          return e
-        end
-      end
-      alias :assert_raise :assert_raises
-
-      def assert_respond_to obj, meth, msg = "Expected #{obj.inspect} of type #{obj.class} to respond_to? #{meth.inspect}"
-        assert obj.respond_to?(meth), msg
-      end
-
-      def assert_same exp, act, msg = "Expected #{act.inspect} to be the same as #{exp.inspect}."
-        assert exp.equal?(act), msg
-      end
-
-      def assert_send send, msg = nil
-        recv, meth, *args = send
-        assert(recv.__send__(meth, *args),
-               msg || "<#{recv.inspect}> expected to respond to\n<#{meth.inspect}> with a true value.")
-      end
-
-      def assert_throws sym, msg = "<#{sym.inspect}> should have been thrown."
-        caught = true
-        catch(sym) do
-          yield rescue nil
-          caught = false
-        end
-        assert caught, msg
-      end
+      alias :method_name :name # so lame
+    end
+  end
+end
 
-      def flunk msg = "Flunked"
-        assert false, msg
-      end
-    end # class TestCase
-  end # class Unit
-end # module MiniTest
+require 'test/unit/assertions' # brings in deprecated methods
 
-Test = MiniTest unless defined? Test
+Mini::Test.autorun

data/lib/test/unit/assertions.rb

@@ -0,0 +1,75 @@
+require 'mini/test'
+require 'test/unit'
+
+module Test::Unit # patch up bastards that that extend improperly.
+  if defined? Assertions then
+    warn "ARGH! someone defined Test::Unit::Assertions rather than requiring"
+    CRAP_ASSERTIONS = Assertions
+    remove_const :Assertions
+
+    ObjectSpace.each_object(Module) do |offender|
+      offender.send :include, ::Mini::Assertions if offender < CRAP_ASSERTIONS
+    end rescue :fuck_you_then!
+
+    Test::Unit::TestCase.send :include, CRAP_ASSERTIONS
+  end
+
+  Assertions = ::Mini::Assertions
+
+  module Assertions
+    def self.included x
+      x.send :include, Test::Unit::CRAP_ASSERTIONS
+    end if defined? Test::Unit::CRAP_ASSERTIONS
+  end
+end
+
+class Module # define deprecation api
+  DEPS = Hash.new { |h,k| h[k] = {} }
+
+  def deprecation_warning old, new = nil, kaller = nil
+    kaller ||= caller[1]
+    unless DEPS[old][kaller] then
+      msg = "#{self}##{old} deprecated. "
+      msg += new ? "Use ##{new}" : "No replacement is provided"
+      msg += ". From #{kaller}."
+      warn msg
+    end
+    DEPS[old][kaller] = true
+  end
+
+  def deprecate old, new
+    class_eval <<-EOM
+      def #{old} *args, &block
+        cls, clr = self.class, caller.first
+        self.class.deprecation_warning #{old.inspect}, #{new.inspect}, clr
+        #{new}(*args, &block)
+      end
+    EOM
+  end
+end
+
+module Test::Unit
+  module Assertions # deprecations
+    deprecate :assert_nothing_thrown, :assert_nothing_raised # drop 2009-06-01
+    deprecate :assert_raise,          :assert_raises         # drop 2010-06-01
+    deprecate :assert_not_equal,      :refute_equal          # drop 2009-06-01
+    deprecate :assert_no_match,       :refute_match          # drop 2009-06-01
+    deprecate :assert_not_nil,        :refute_nil            # drop 2009-06-01
+    deprecate :assert_not_same,       :refute_same           # drop 2009-06-01
+
+    def assert_nothing_raised _ = :ignored                   # drop 2009-06-01
+      self.class.deprecation_warning :assert_nothing_raised
+      self._assertions += 1
+      yield
+    rescue => e
+      raise Mini::Assertion, exception_details(e, "Exception raised:")
+    end
+
+    def build_message(user_message, template_message, *args) # drop 2009-06-01
+      user_message ||= ''
+      user_message += ' ' unless user_message.empty?
+      msg = template_message.split(/<\?>/).zip(args.map { |o| o.inspect })
+      user_message + msg.join
+    end
+  end
+end

data/lib/test/unit/error.rb

@@ -0,0 +1,8 @@
+# rails currently needs this file and this one method.
+module Test::Unit
+  class Error
+    def message
+      "you're a loser"
+    end
+  end
+end

data/lib/test/unit/testcase.rb

@@ -1,7 +1,2 @@
 # don't define anything, this is just so we don't get the real one
-
-$TEST_UNIT_TESTCASE_DEPRECATION ||= false
-
-warn "require 'test/unit/testcase' has been deprecated" unless $TEST_UNIT_TESTCASE_DEPRECATION
-
-$TEST_UNIT_TESTCASE_DEPRECATION = true
+warn "require 'test/unit/testcase' has been deprecated"

data/test/test_mini_mock.rb

@@ -0,0 +1,76 @@
+require 'mini/mock'
+
+Mini::Test.autorun
+
+class TestMiniMock < Mini::Test::TestCase
+  def setup
+    @mock = Mini::Mock.new.expect(:foo, nil)
+    @mock.expect(:meaning_of_life, 42)
+  end
+
+  def test_should_create_stub_method
+    assert_nil @mock.foo
+  end
+
+  def test_should_allow_return_value_specification
+    assert_equal 42, @mock.meaning_of_life
+  end
+
+  def test_should_blow_up_if_not_called
+    @mock.foo
+
+    util_verify_bad
+  end
+
+  def test_should_not_blow_up_if_everything_called
+    @mock.foo
+    @mock.meaning_of_life
+
+    assert @mock.verify
+  end
+
+  def test_should_allow_expectations_to_be_added_after_creation
+    @mock.expect(:bar, true)
+    assert @mock.bar
+  end
+
+  def test_should_not_verify_if_new_expected_method_is_not_called
+    @mock.foo
+    @mock.meaning_of_life
+    @mock.expect(:bar, true)
+
+    util_verify_bad
+  end
+
+  def test_should_not_verify_if_unexpected_method_is_called
+    assert_raises NoMethodError do
+      @mock.unexpected
+    end
+  end
+
+  def test_should_blow_up_on_wrong_number_of_arguments
+    @mock.foo
+    @mock.meaning_of_life
+    @mock.expect(:sum, 3, [1, 2])
+
+    assert_raises ArgumentError do
+      @mock.sum
+    end
+  end
+
+  def test_should_blow_up_on_wrong_arguments
+    @mock.foo
+    @mock.meaning_of_life
+    @mock.expect(:sum, 3, [1, 2])
+
+    @mock.sum(2, 4)
+
+    util_verify_bad
+  end
+
+  def util_verify_bad
+    assert_raises MockExpectationError do
+      @mock.verify
+    end
+  end
+end