spec 5.0.19 → 5.3.3

data/lib/minitest/assertions.rb

@@ -6,7 +6,7 @@ module Minitest
   # printed if the assertion fails.
   #
   # Protocol: Nearly everything here boils up to +assert+, which
-  # expects to be able to increment an instance variable named
+  # expects to be able to increment an instance accessor named
   # +assertions+. This is not provided by Assertions and must be
   # provided by the thing including Assertions. See Minitest::Runnable
   # for an example.
@@ -131,6 +131,10 @@ module Minitest
       true
     end
 
+    def _synchronize # :nodoc:
+      yield
+    end
+
     ##
     # Fails unless +obj+ is empty.
 
@@ -393,6 +397,8 @@ module Minitest
     # that.
 
     def capture_io
+      _synchronize do
+        begin
       require 'stringio'
 
       captured_stdout, captured_stderr = StringIO.new, StringIO.new
@@ -406,6 +412,8 @@ module Minitest
     ensure
       $stdout = orig_stdout
       $stderr = orig_stderr
+        end
+      end
     end
 
     ##
@@ -424,6 +432,8 @@ module Minitest
     # only use it when you need to test the output of a subprocess.
 
     def capture_subprocess_io
+      _synchronize do
+        begin
       require 'tempfile'
 
       captured_stdout, captured_stderr = Tempfile.new("out"), Tempfile.new("err")
@@ -443,6 +453,8 @@ module Minitest
       captured_stderr.unlink
       $stdout.reopen orig_stdout
       $stderr.reopen orig_stderr
+        end
+      end
     end
 
     ##

data/lib/minitest/benchmark.rb

@@ -376,7 +376,7 @@ module Minitest
     ##
     # Create a benchmark that verifies that the performance is linear.
     #
-    #   describe "my class" do
+    #   describe "my class Bench" do
     #     bench_performance_linear "fast_algorithm", 0.9999 do |n|
     #       @obj.fast_algorithm(n)
     #     end
@@ -391,7 +391,7 @@ module Minitest
     ##
     # Create a benchmark that verifies that the performance is constant.
     #
-    #   describe "my class" do
+    #   describe "my class Bench" do
     #     bench_performance_constant "zoom_algorithm!" do |n|
     #       @obj.zoom_algorithm!(n)
     #     end
@@ -406,7 +406,7 @@ module Minitest
     ##
     # Create a benchmark that verifies that the performance is exponential.
     #
-    #   describe "my class" do
+    #   describe "my class Bench" do
     #     bench_performance_exponential "algorithm" do |n|
     #       @obj.algorithm(n)
     #     end

data/lib/minitest/hell.rb

@@ -1,4 +1,4 @@
-require "minitest/parallel_each"
+require "minitest/parallel"
 
 class Minitest::Test
   class << self

data/lib/minitest/mock.rb

@@ -109,7 +109,7 @@ module Minitest # :nodoc:
       true
     end
 
-    def method_missing(sym, *args) # :nodoc:
+    def method_missing(sym, *args, &block) # :nodoc:
       unless @expected_calls.has_key?(sym) then
         raise NoMethodError, "unmocked method %p, expected one of %p" %
           [sym, @expected_calls.keys.sort_by(&:to_s)]
@@ -128,7 +128,7 @@ module Minitest # :nodoc:
 
       if val_block then
         raise MockExpectationError, "mocked method %p failed block w/ %p" %
-          [sym, args] unless val_block.call(args)
+          [sym, args] unless val_block.call(*args, &block)
 
         # keep "verify" happy
         @actual_calls[sym] << expected_call

data/lib/minitest/parallel.rb

@@ -0,0 +1,40 @@
+module Minitest
+  module Parallel
+    class Executor
+      attr_reader :size
+
+      def initialize size
+        @size  = size
+        @queue = Queue.new
+        @pool  = size.times.map {
+          Thread.new(@queue) do |queue|
+          Thread.current.abort_on_exception = true
+            while job = queue.pop
+              klass, method, reporter = job
+              result = Minitest.run_one_method klass, method
+              reporter.synchronize { reporter.record result }
+            end
+          end
+        }
+      end
+
+      def << work; @queue << work; end
+
+      def shutdown
+        size.times { @queue << nil }
+        @pool.each(&:join)
+      end
+    end
+
+    module Test
+      def _synchronize; Test.io_lock.synchronize { yield }; end
+
+      module ClassMethods
+        def run_one_method klass, method_name, reporter
+          Minitest.parallel_executor << [klass, method_name, reporter]
+        end
+        def test_order; :parallel; end
+      end
+    end
+  end
+end

data/lib/minitest/pride_plugin.rb

@@ -1,4 +1,4 @@
-require "minitest/autorun"
+require "minitest"
 
 module Minitest
   def self.plugin_pride_options opts, options # :nodoc:
@@ -52,7 +52,6 @@ module Minitest
       @colors ||= (31..36).to_a
       @size   = @colors.size
       @index  = 0
-      # io.sync = true
     end
 
     ##

data/lib/minitest/spec.rb

@@ -1,5 +1,3 @@
-#!/usr/bin/ruby -w
-
 require 'minitest/unit'
 
 class Module # :nodoc:
@@ -8,10 +6,10 @@ class Module # :nodoc:
     self.class_eval <<-EOM
       def #{new_name} *args
         case
-        when Proc === self then
-          Minitest::Spec.current.#{meth}(*args, &self)
         when #{!!dont_flip} then
           Minitest::Spec.current.#{meth}(self, *args)
+        when Proc === self then
+          Minitest::Spec.current.#{meth}(*args, &self)
         else
           Minitest::Spec.current.#{meth}(args.first, self, *args[1..-1])
         end
@@ -161,13 +159,6 @@ class Minitest::Spec < Minitest::Test
       end
     end
 
-    def before_first type = nil, &block
-      define_method :before_first_method do
-        super()
-        self.instance_eval(&block)
-      end
-    end
-
     ##
     # Define a 'before' action. Inherits the way normal methods should.
     #
@@ -196,13 +187,6 @@ class Minitest::Spec < Minitest::Test
       end
     end
 
-    def after_last type = nil, &block
-      define_method :after_last_method do
-        self.instance_eval(&block)
-        super()
-      end
-    end
-
     ##
     # Define an expectation with name +desc+. Name gets morphed to a
     # proper test method name. For some freakish reason, people who
@@ -211,7 +195,7 @@ class Minitest::Spec < Minitest::Test
     #
     # This is also aliased to #specify and doesn't require a +desc+ arg.
     #
-    # Hint: If you _do_ want inheritence, use minitest/test. You can mix
+    # Hint: If you _do_ want inheritance, use minitest/test. You can mix
     # and match between assertions and expectations as much as you want.
 
     def it desc = "anonymous", &block
@@ -231,15 +215,20 @@ class Minitest::Spec < Minitest::Test
       name
     end
 
-    alias_method :t, :it
-
     ##
     # Essentially, define an accessor for +name+ with +block+.
     #
     # Why use let instead of def? I honestly don't know.
 
     def let name, &block
-      raise ArgumentError, 'name cannot begin with "test"' if name.to_s =~ /\Atest/
+      name = name.to_s
+      pre, post = "let '#{name}' cannot ", ". Please use another name."
+      methods = Minitest::Spec.instance_methods.map(&:to_s) - %w[subject]
+      raise ArgumentError, "#{pre}begin with 'test'#{post}" if
+        name =~ /\Atest/
+      raise ArgumentError, "#{pre}override a method in Minitest::Spec#{post}" if
+        methods.include? name
+
       define_method name do
         @_memoized ||= {}
         @_memoized.fetch(name) { |k| @_memoized[k] = instance_eval(&block) }
@@ -278,6 +267,18 @@ class Minitest::Spec < Minitest::Test
     # :stopdoc:
     attr_reader :desc
     alias :specify :it
+
+    module InstanceMethods
+      def before_setup
+        super
+        Thread.current[:current_spec] = self
+      end
+    end
+
+    def self.extended obj
+      obj.send :include, InstanceMethods
+    end
+
     # :startdoc:
   end
 

data/lib/minitest/test.rb

@@ -14,6 +14,9 @@ module Minitest
     PASSTHROUGH_EXCEPTIONS = [NoMemoryError, SignalException, # :nodoc:
                               Interrupt, SystemExit]
 
+    class << self; attr_accessor :io_lock; end
+    self.io_lock = Mutex.new
+
     ##
     # Call this at the top of your tests when you absolutely
     # positively need to have ordered tests. In doing so, you're
@@ -46,19 +49,27 @@ module Minitest
     # and your tests are awesome.
 
     def self.parallelize_me!
-      require "minitest/parallel_each"
-
-      class << self
-        undef_method :test_order if method_defined? :test_order
-        define_method :test_order do :parallel end
-      end
+      include Minitest::Parallel::Test
+      extend Minitest::Parallel::Test::ClassMethods
     end
 
     ##
-    # Returns all instance methods starting with "test_".
+    # Returns all instance methods starting with "test_". Based on
+    # #test_order, the methods are either sorted, randomized
+    # (default), or run in parallel.
 
     def self.runnable_methods
-      methods_matching(/^test_/)
+      methods = methods_matching(/^test_/)
+
+      case self.test_order
+      when :random, :parallel then
+        max = methods.size
+        methods.sort.sort_by { rand max }
+      when :alpha, :sorted then
+        methods.sort
+      else
+        raise "Unknown test_order: #{self.test_order.inspect}"
+      end
     end
 
     ##

data/lib/spec.rb

@@ -1,3 +1,157 @@
 # enable require 'spec'
-require File.expand_path '../minitest.rb', __FILE__
-require File.expand_path '../minitest/spec.rb', __FILE__
+require_relative 'minitest'
+require_relative 'minitest/spec'
+
+# patches to enable Appium spec
+
+require 'rubygems'
+require 'chronic_duration'
+
+
+module Minitest
+  # override minitest.rb __run so tests execute serially
+  def self.__run reporter, options
+    Runnable.runnables.each do |runnable|
+      runnable.run reporter, options
+    end
+  end
+
+  ##
+  # Trace file source to :io (default $stdout)
+  #
+  # spec_opts = {}
+  #
+  # @param :trace [Array<String>] the files to trace
+  # @param :io [IO] io to print to
+  def self.trace_specs spec_opts
+    targets   = []
+    files     = {}
+    last_file = ''
+    last_line = -1
+
+    files_to_trace = spec_opts.fetch(:trace, []);
+    io    = spec_opts.fetch(:io, $stdout)
+    color = spec_opts.fetch(:color, "\e[32m") # ANSI.green default
+    # target only existing readable files
+    files_to_trace.each do |f|
+      if File.exists?(f) && File.readable?(f)
+        targets.push File.expand_path f
+        targets.push File.basename f # sometimes the file is relative
+      end
+    end
+    return if targets.empty?
+
+    set_trace_func(lambda do |event, file, line, id, binding, classname|
+      return unless targets.include?(file)
+
+      # never repeat a line
+      return if file == last_file && line == last_line
+
+      file_sym        = file.intern
+      files[file_sym] = IO.readlines(file) if files[file_sym].nil?
+      lines           = files[file_sym]
+
+      # arrays are 0 indexed and line numbers start at one.
+      io.print color if color # ANSI code
+      io.puts lines[line - 1]
+      io.print "\e[0m" if color # ANSI.clear
+
+      last_file = file
+      last_line = line
+
+    end)
+  end
+
+  def self.on_exit exit_code
+    @@after_run.reverse_each(&:call)
+    exit exit_code || false
+  end
+
+  ##
+  # Run specs. Does not print dots (ProgressReporter)
+  #
+  # spec_opts
+  # @param :io [Array<String>] defaults to $stdout
+  # @param :trace [Array<String>] files to trace
+  def self.run_specs spec_opts={}
+    options  = { :io      => spec_opts.fetch(:io, $stdout),
+                 :verbose => spec_opts.fetch(:verbose, false) }
+    reporter = Minitest::CompositeReporter.new
+    reporter << Minitest::SummaryReporter.new(options[:io], options)
+    reporter.start
+
+    at_exit { on_exit reporter.passed? }
+    # exit on ctrl+c to trigger at_exit
+    trap('SIGINT') { exit }
+
+    trace_specs spec_opts
+
+    Minitest.__run reporter, options
+    reporter.reporters.each { |r| r.report }
+  end
+
+  ##
+  # Responsible for running all runnable methods in a given class,
+  # each in its own instance. Each instance is passed to the
+  # reporter to record.
+
+  def self.run reporter, options = {}
+    filter = options[:filter] || '/./'
+    filter = Regexp.new $1 if filter =~ /\/(.*)\//
+
+    filtered_methods = self.runnable_methods.find_all { |m|
+      filter === m || filter === "#{self}##{m}"
+    }
+
+    with_info_handler reporter do
+      filtered_methods.each do |method_name|
+
+        method = self.new(method_name)
+        matched_name = method_name.match /test_(\d+)_/
+        if matched_name
+          test_number = matched_name[1].to_i
+          test_name = method_name.split(/_\d+_/).last
+          file_path, line_number = method.method(method_name).source_location
+          # /5/4/3/2/1/test.rb => 2/1/test.rb
+          file_path = file_path.split(File::SEPARATOR).reject(&:empty?)
+          file_path = (file_path.length >= 3 ? file_path[-3..-1] :
+              file_path).join(File::SEPARATOR)
+          # 36 = cyan, 0 = clear
+          test_output_title = "\e[36m#{test_name} | #{test_number} |" +
+              "#{file_path}:#{line_number}\e[0m"
+          io.puts test_output_title
+        end
+
+        run_one_method self, method_name, reporter
+      end
+    end
+  end
+
+  class Test < Runnable
+    # override lib/minitest/test.rb so methods execute in the exact order they are defined
+    def self.runnable_methods
+      methods_matching(/^test_/)
+    end
+  end
+
+  class SummaryReporter < StatisticsReporter
+    # remove dots
+    def start # :nodoc:
+      super
+
+      self.sync = io.respond_to? :"sync=" # stupid emacs
+      self.old_sync, io.sync = io.sync, true if self.sync
+    end
+
+    # customize stats
+    def statistics # :nodoc:
+      "Finished in #{ChronicDuration.output(total_time.round) || '0s'}"
+    end
+  end
+
+  class Minitest::Spec < Minitest::Test
+    module DSL
+      alias_method :t, :it
+    end
+  end
+end