minitest 4.7.5 → 5.0.7

data/lib/minitest/benchmark.rb

@@ -1,16 +1,32 @@
 require 'minitest/unit'
 require 'minitest/spec'
 
-class MiniTest::Unit # :nodoc:
-  def run_benchmarks # :nodoc:
-    _run_anything :benchmark
-  end
+module Minitest
+  ##
+  # Subclass Benchmark to create your own benchmark runs. Methods
+  # starting with "bench_" get executed on a per-class.
+  #
+  # See Minitest::Assertions
 
-  def benchmark_suite_header suite # :nodoc:
-    "\n#{suite}\t#{suite.bench_range.join("\t")}"
-  end
+  class Benchmark < Test
+    def self.io # :nodoc:
+      @io
+    end
+
+    def io # :nodoc:
+      self.class.io
+    end
+
+    def self.run reporter, options = {} # :nodoc:
+      # NOTE: this is truly horrible... but I don't see a way around this ATM.
+      @io = reporter.reporters.first.io
+      super
+    end
+
+    def self.runnable_methods # :nodoc:
+      methods_matching(/^bench_/)
+    end
 
-  class TestCase
     ##
     # Returns a set of ranges stepped exponentially from +min+ to
     # +max+ by powers of +base+. Eg:
@@ -36,21 +52,6 @@ class MiniTest::Unit # :nodoc:
       r = []; (min..max).step(step) { |n| r << n }; r
     end
 
-    ##
-    # Returns the benchmark methods (methods that start with bench_)
-    # for that class.
-
-    def self.benchmark_methods # :nodoc:
-      public_instance_methods(true).grep(/^bench_/).map { |m| m.to_s }.sort
-    end
-
-    ##
-    # Returns all test suites that have benchmark methods.
-
-    def self.benchmark_suites
-      TestCase.test_suites.reject { |s| s.benchmark_methods.empty? }
-    end
-
     ##
     # Specifies the ranges used for benchmarking for that class.
     # Defaults to exponential growth from 1 to 10k by powers of 10.
@@ -83,7 +84,7 @@ class MiniTest::Unit # :nodoc:
     def assert_performance validation, &work
       range = self.class.bench_range
 
-      io.print "#{__name__}"
+      io.print "#{self.name}"
 
       times = []
 
@@ -341,76 +342,82 @@ class MiniTest::Unit # :nodoc:
   end
 end
 
-class MiniTest::Spec
-  ##
-  # This is used to define a new benchmark method. You usually don't
-  # use this directly and is intended for those needing to write new
-  # performance curve fits (eg: you need a specific polynomial fit).
-  #
-  # See ::bench_performance_linear for an example of how to use this.
+module Minitest
+  class BenchSpec < Benchmark
+    extend Minitest::Spec::DSL
 
-  def self.bench name, &block
-    define_method "bench_#{name.gsub(/\W+/, '_')}", &block
-  end
+    ##
+    # This is used to define a new benchmark method. You usually don't
+    # use this directly and is intended for those needing to write new
+    # performance curve fits (eg: you need a specific polynomial fit).
+    #
+    # See ::bench_performance_linear for an example of how to use this.
 
-  ##
-  # Specifies the ranges used for benchmarking for that class.
-  #
-  #   bench_range do
-  #     bench_exp(2, 16, 2)
-  #   end
-  #
-  # See Unit::TestCase.bench_range for more details.
+    def self.bench name, &block
+      define_method "bench_#{name.gsub(/\W+/, '_')}", &block
+    end
+
+    ##
+    # Specifies the ranges used for benchmarking for that class.
+    #
+    #   bench_range do
+    #     bench_exp(2, 16, 2)
+    #   end
+    #
+    # See Minitest::Benchmark#bench_range for more details.
 
-  def self.bench_range &block
-    return super unless block
+    def self.bench_range &block
+      return super unless block
 
-    meta = (class << self; self; end)
-    meta.send :define_method, "bench_range", &block
-  end
+      meta = (class << self; self; end)
+      meta.send :define_method, "bench_range", &block
+    end
 
-  ##
-  # Create a benchmark that verifies that the performance is linear.
-  #
-  #   describe "my class" do
-  #     bench_performance_linear "fast_algorithm", 0.9999 do |n|
-  #       @obj.fast_algorithm(n)
-  #     end
-  #   end
-
-  def self.bench_performance_linear name, threshold = 0.99, &work
-    bench name do
-      assert_performance_linear threshold, &work
+    ##
+    # Create a benchmark that verifies that the performance is linear.
+    #
+    #   describe "my class" do
+    #     bench_performance_linear "fast_algorithm", 0.9999 do |n|
+    #       @obj.fast_algorithm(n)
+    #     end
+    #   end
+
+    def self.bench_performance_linear name, threshold = 0.99, &work
+      bench name do
+        assert_performance_linear threshold, &work
+      end
     end
-  end
 
-  ##
-  # Create a benchmark that verifies that the performance is constant.
-  #
-  #   describe "my class" do
-  #     bench_performance_constant "zoom_algorithm!" do |n|
-  #       @obj.zoom_algorithm!(n)
-  #     end
-  #   end
-
-  def self.bench_performance_constant name, threshold = 0.99, &work
-    bench name do
-      assert_performance_constant threshold, &work
+    ##
+    # Create a benchmark that verifies that the performance is constant.
+    #
+    #   describe "my class" do
+    #     bench_performance_constant "zoom_algorithm!" do |n|
+    #       @obj.zoom_algorithm!(n)
+    #     end
+    #   end
+
+    def self.bench_performance_constant name, threshold = 0.99, &work
+      bench name do
+        assert_performance_constant threshold, &work
+      end
     end
-  end
 
-  ##
-  # Create a benchmark that verifies that the performance is exponential.
-  #
-  #   describe "my class" do
-  #     bench_performance_exponential "algorithm" do |n|
-  #       @obj.algorithm(n)
-  #     end
-  #   end
-
-  def self.bench_performance_exponential name, threshold = 0.99, &work
-    bench name do
-      assert_performance_exponential threshold, &work
+    ##
+    # Create a benchmark that verifies that the performance is exponential.
+    #
+    #   describe "my class" do
+    #     bench_performance_exponential "algorithm" do |n|
+    #       @obj.algorithm(n)
+    #     end
+    #   end
+
+    def self.bench_performance_exponential name, threshold = 0.99, &work
+      bench name do
+        assert_performance_exponential threshold, &work
+      end
     end
   end
+
+  Minitest::Spec.register_spec_type(/Bench(mark)?$/, Minitest::BenchSpec)
 end

data/lib/minitest/expectations.rb

@@ -0,0 +1,281 @@
+##
+# It's where you hide your "assertions".
+#
+# Please note, because of the way that expectations are implemented,
+# all expectations (eg must_equal) are dependent upon a thread local
+# variable +:current_spec+. If your specs rely on mixing threads into
+# the specs themselves, you're better off using assertions. For
+# example:
+#
+#     it "should still work in threads" do
+#       my_threaded_thingy do
+#         (1+1).must_equal 2  # bad
+#         assert_equal 2, 1+1 # good
+#       end
+#     end
+
+module Minitest::Expectations
+  ##
+  # See Minitest::Assertions#assert_empty.
+  #
+  #    collection.must_be_empty
+  #
+  # :method: must_be_empty
+
+  infect_an_assertion :assert_empty, :must_be_empty, :unary
+
+  ##
+  # See Minitest::Assertions#assert_equal
+  #
+  #    a.must_equal b
+  #
+  # :method: must_equal
+
+  infect_an_assertion :assert_equal, :must_equal
+
+  ##
+  # See Minitest::Assertions#assert_in_delta
+  #
+  #    n.must_be_close_to m [, delta]
+  #
+  # :method: must_be_close_to
+
+  infect_an_assertion :assert_in_delta, :must_be_close_to
+
+  alias :must_be_within_delta :must_be_close_to # :nodoc:
+
+  ##
+  # See Minitest::Assertions#assert_in_epsilon
+  #
+  #    n.must_be_within_epsilon m [, epsilon]
+  #
+  # :method: must_be_within_epsilon
+
+  infect_an_assertion :assert_in_epsilon, :must_be_within_epsilon
+
+  ##
+  # See Minitest::Assertions#assert_includes
+  #
+  #    collection.must_include obj
+  #
+  # :method: must_include
+
+  infect_an_assertion :assert_includes, :must_include, :reverse
+
+  ##
+  # See Minitest::Assertions#assert_instance_of
+  #
+  #    obj.must_be_instance_of klass
+  #
+  # :method: must_be_instance_of
+
+  infect_an_assertion :assert_instance_of, :must_be_instance_of
+
+  ##
+  # See Minitest::Assertions#assert_kind_of
+  #
+  #    obj.must_be_kind_of mod
+  #
+  # :method: must_be_kind_of
+
+  infect_an_assertion :assert_kind_of, :must_be_kind_of
+
+  ##
+  # See Minitest::Assertions#assert_match
+  #
+  #    a.must_match b
+  #
+  # :method: must_match
+
+  infect_an_assertion :assert_match, :must_match
+
+  ##
+  # See Minitest::Assertions#assert_nil
+  #
+  #    obj.must_be_nil
+  #
+  # :method: must_be_nil
+
+  infect_an_assertion :assert_nil, :must_be_nil, :unary
+
+  ##
+  # See Minitest::Assertions#assert_operator
+  #
+  #    n.must_be :<=, 42
+  #
+  # This can also do predicates:
+  #
+  #    str.must_be :empty?
+  #
+  # :method: must_be
+
+  infect_an_assertion :assert_operator, :must_be, :reverse
+
+  ##
+  # See Minitest::Assertions#assert_output
+  #
+  #    proc { ... }.must_output out_or_nil [, err]
+  #
+  # :method: must_output
+
+  infect_an_assertion :assert_output, :must_output
+
+  ##
+  # See Minitest::Assertions#assert_raises
+  #
+  #    proc { ... }.must_raise exception
+  #
+  # :method: must_raise
+
+  infect_an_assertion :assert_raises, :must_raise
+
+  ##
+  # See Minitest::Assertions#assert_respond_to
+  #
+  #    obj.must_respond_to msg
+  #
+  # :method: must_respond_to
+
+  infect_an_assertion :assert_respond_to, :must_respond_to, :reverse
+
+  ##
+  # See Minitest::Assertions#assert_same
+  #
+  #    a.must_be_same_as b
+  #
+  # :method: must_be_same_as
+
+  infect_an_assertion :assert_same, :must_be_same_as
+
+  ##
+  # See Minitest::Assertions#assert_silent
+  #
+  #    proc { ... }.must_be_silent
+  #
+  # :method: must_be_silent
+
+  infect_an_assertion :assert_silent, :must_be_silent
+
+  ##
+  # See Minitest::Assertions#assert_throws
+  #
+  #    proc { ... }.must_throw sym
+  #
+  # :method: must_throw
+
+  infect_an_assertion :assert_throws, :must_throw
+
+  ##
+  # See Minitest::Assertions#refute_empty
+  #
+  #    collection.wont_be_empty
+  #
+  # :method: wont_be_empty
+
+  infect_an_assertion :refute_empty, :wont_be_empty, :unary
+
+  ##
+  # See Minitest::Assertions#refute_equal
+  #
+  #    a.wont_equal b
+  #
+  # :method: wont_equal
+
+  infect_an_assertion :refute_equal, :wont_equal
+
+  ##
+  # See Minitest::Assertions#refute_in_delta
+  #
+  #    n.wont_be_close_to m [, delta]
+  #
+  # :method: wont_be_close_to
+
+  infect_an_assertion :refute_in_delta, :wont_be_close_to
+
+  alias :wont_be_within_delta :wont_be_close_to # :nodoc:
+
+  ##
+  # See Minitest::Assertions#refute_in_epsilon
+  #
+  #    n.wont_be_within_epsilon m [, epsilon]
+  #
+  # :method: wont_be_within_epsilon
+
+  infect_an_assertion :refute_in_epsilon, :wont_be_within_epsilon
+
+  ##
+  # See Minitest::Assertions#refute_includes
+  #
+  #    collection.wont_include obj
+  #
+  # :method: wont_include
+
+  infect_an_assertion :refute_includes, :wont_include, :reverse
+
+  ##
+  # See Minitest::Assertions#refute_instance_of
+  #
+  #    obj.wont_be_instance_of klass
+  #
+  # :method: wont_be_instance_of
+
+  infect_an_assertion :refute_instance_of, :wont_be_instance_of
+
+  ##
+  # See Minitest::Assertions#refute_kind_of
+  #
+  #    obj.wont_be_kind_of mod
+  #
+  # :method: wont_be_kind_of
+
+  infect_an_assertion :refute_kind_of, :wont_be_kind_of
+
+  ##
+  # See Minitest::Assertions#refute_match
+  #
+  #    a.wont_match b
+  #
+  # :method: wont_match
+
+  infect_an_assertion :refute_match, :wont_match
+
+  ##
+  # See Minitest::Assertions#refute_nil
+  #
+  #    obj.wont_be_nil
+  #
+  # :method: wont_be_nil
+
+  infect_an_assertion :refute_nil, :wont_be_nil, :unary
+
+  ##
+  # See Minitest::Assertions#refute_operator
+  #
+  #    n.wont_be :<=, 42
+  #
+  # This can also do predicates:
+  #
+  #    str.wont_be :empty?
+  #
+  # :method: wont_be
+
+  infect_an_assertion :refute_operator, :wont_be, :reverse
+
+  ##
+  # See Minitest::Assertions#refute_respond_to
+  #
+  #    obj.wont_respond_to msg
+  #
+  # :method: wont_respond_to
+
+  infect_an_assertion :refute_respond_to, :wont_respond_to, :reverse
+
+  ##
+  # See Minitest::Assertions#refute_same
+  #
+  #    a.wont_be_same_as b
+  #
+  # :method: wont_be_same_as
+
+  infect_an_assertion :refute_same, :wont_be_same_as
+end

data/lib/minitest/hell.rb

@@ -1,13 +1,11 @@
 require "minitest/parallel_each"
 
-# :stopdoc:
-class Minitest::Unit::TestCase
+class Minitest::Test
   class << self
-    alias :old_test_order :test_order
+    alias :old_test_order :test_order # :nodoc:
 
-    def test_order
+    def test_order # :nodoc:
       :parallel
     end
   end
 end
-# :startdoc:

data/lib/minitest/mock.rb

@@ -1,20 +1,37 @@
 class MockExpectationError < StandardError; end # :nodoc:
 
-##
-# A simple and clean mock object framework.
-
-module MiniTest # :nodoc:
+module Minitest # :nodoc:
 
   ##
+  # A simple and clean mock object framework.
+  #
   # All mock objects are an instance of Mock
 
   class Mock
     alias :__respond_to? :respond_to?
 
-    skip_methods = %w(object_id respond_to_missing? inspect === to_s)
+    overridden_methods = %w(
+      ===
+      inspect
+      object_id
+      public_send
+      respond_to_missing?
+      send
+      to_s
+    )
 
     instance_methods.each do |m|
-      undef_method m unless skip_methods.include?(m.to_s) || m =~ /^__/
+      undef_method m unless overridden_methods.include?(m.to_s) || m =~ /^__/
+    end
+
+    overridden_methods.map(&:to_sym).each do |method_id|
+      define_method method_id do |*args, &b|
+        if @expected_calls.has_key? method_id then
+          method_missing(method_id, *args, &b)
+        else
+          super(*args, &b)
+        end
+      end
     end
 
     def initialize # :nodoc:
@@ -43,11 +60,13 @@ module MiniTest # :nodoc:
     #   @mock.uses_any_string("foo") # => true
     #   @mock.verify  # => true
     #
-    #   @mock.expect(:uses_one_string, true, ["foo"]
+    #   @mock.expect(:uses_one_string, true, ["foo"])
     #   @mock.uses_one_string("bar") # => true
     #   @mock.verify  # => raises MockExpectationError
 
     def expect(name, retval, args=[], &blk)
+      name = name.to_sym
+
       if block_given?
         raise ArgumentError, "args ignored when block given" unless args.empty?
         @expected_calls[name] << { :retval => retval, :block => blk }
@@ -139,7 +158,7 @@ module MiniTest # :nodoc:
     end
 
     def respond_to?(sym, include_private = false) # :nodoc:
-      return true if @expected_calls.has_key?(sym.to_sym)
+      return true if @expected_calls.has_key? sym.to_sym
       return __respond_to?(sym, include_private)
     end
   end
@@ -151,8 +170,9 @@ class Object # :nodoc:
   # Add a temporary stubbed method replacing +name+ for the duration
   # of the +block+. If +val_or_callable+ responds to #call, then it
   # returns the result of calling it, otherwise returns the value
-  # as-is. Cleans up the stub at the end of the +block+. The method
-  # +name+ must exist before stubbing.
+  # as-is. If stubbed method yields a block, +block_args+ will be
+  # passed along. Cleans up the stub at the end of the +block+. The
+  # method +name+ must exist before stubbing.
   #
   #     def test_stale_eh
   #       obj_under_test = Something.new
@@ -162,8 +182,9 @@ class Object # :nodoc:
   #         assert obj_under_test.stale?
   #       end
   #     end
+  #
 
-  def stub name, val_or_callable, &block
+  def stub name, val_or_callable, *block_args, &block
     new_name = "__minitest_stub__#{name}"
 
     metaclass = class << self; self; end
@@ -176,12 +197,17 @@ class Object # :nodoc:
 
     metaclass.send :alias_method, new_name, name
 
-    metaclass.send :define_method, name do |*args|
-      if val_or_callable.respond_to? :call then
+    metaclass.send :define_method, name do |*args, &blk|
+
+      ret = if val_or_callable.respond_to? :call then
         val_or_callable.call(*args)
       else
         val_or_callable
       end
+
+      blk.call(*block_args) if blk
+
+      ret
     end
 
     yield self
@@ -190,4 +216,5 @@ class Object # :nodoc:
     metaclass.send :alias_method, name, new_name
     metaclass.send :undef_method, new_name
   end
+
 end