Class: MiniTest::Unit

Inherits:
Object show all
Defined in:
lib/minitest/unit.rb,
lib/minitest/benchmark.rb

Defined Under Namespace

Classes: TestCase

Constant Summary collapse

VERSION =

:nodoc:

"2.5.1"
@@out = 
$stdout

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Unit

:nodoc:



831
832
833
834
835
 
# File 'lib/minitest/unit.rb', line 831

def initialize # :nodoc:
  @report = []
  @errors = @failures = @skips = 0
  @verbose = false
end

Instance Attribute Details

#assertion_count ⇒ Object

Returns the value of attribute assertion_count



626
627
628
 
# File 'lib/minitest/unit.rb', line 626

def assertion_count
  @assertion_count
end

#errors ⇒ Object

Returns the value of attribute errors



625
626
627
 
# File 'lib/minitest/unit.rb', line 625

def errors
  @errors
end

#failures ⇒ Object

Returns the value of attribute failures



625
626
627
 
# File 'lib/minitest/unit.rb', line 625

def failures
  @failures
end

#help ⇒ Object

Returns the value of attribute help



628
629
630
 
# File 'lib/minitest/unit.rb', line 628

def help
  @help
end

#options ⇒ Object 



632
633
634
 
# File 'lib/minitest/unit.rb', line 632

def options
  @options ||= {}
end

#report ⇒ Object

Returns the value of attribute report



625
626
627
 
# File 'lib/minitest/unit.rb', line 625

def report
  @report
end

#runner ⇒ Object

Returns the value of attribute runner



11
12
13
 
# File 'lib/minitest/benchmark.rb', line 11

def runner
  @runner
end

#skips ⇒ Object

Returns the value of attribute skips



625
626
627
 
# File 'lib/minitest/unit.rb', line 625

def skips
  @skips
end

#start_time ⇒ Object

Returns the value of attribute start_time



627
628
629
 
# File 'lib/minitest/unit.rb', line 627

def start_time
  @start_time
end

#test_count ⇒ Object

Returns the value of attribute test_count



626
627
628
 
# File 'lib/minitest/unit.rb', line 626

def test_count
  @test_count
end

#verbose ⇒ Object

Returns the value of attribute verbose



629
630
631
 
# File 'lib/minitest/unit.rb', line 629

def verbose
  @verbose
end

Class Method Details

.after_tests ⇒ Object

A simple hook allowing you to run a block of code after the tests are done. Eg:

MiniTest::Unit.after_tests { p $debugging_info }



645
646
647
 
# File 'lib/minitest/unit.rb', line 645

def self.after_tests
  at_exit { at_exit { yield } }
end

.autorun ⇒ Object

Registers MiniTest::Unit to run tests at process exit



652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
 
# File 'lib/minitest/unit.rb', line 652

def self.autorun
  at_exit {
    next if $! # don't run if there was an exception

    # the order here is important. The at_exit handler must be
    # installed before anyone else gets a chance to install their
    # own, that way we can be assured that our exit will be last
    # to run (at_exit stacks).
    exit_code = nil

    at_exit { exit false if exit_code && exit_code != 0 }

    exit_code = MiniTest::Unit.new.run ARGV
  } unless @@installed_at_exit
  @@installed_at_exit = true
end

.out ⇒ Object

Returns the stream to use for output.

DEPRECATED: use ::output instead.



681
682
683
684
 
# File 'lib/minitest/unit.rb', line 681

def self.out
  warn "::out deprecated, use ::output instead." if $VERBOSE
  output
end

.output ⇒ Object

Returns the stream to use for output.



672
673
674
 
# File 'lib/minitest/unit.rb', line 672

def self.output
  @@out
end

.output=(stream) ⇒ Object

Sets MiniTest::Unit to write output to stream. $stdout is the default output



690
691
692
 
# File 'lib/minitest/unit.rb', line 690

def self.output= stream
  @@out = stream
end

.plugins ⇒ Object

Return all plugins' run methods (methods that start with "run_").



714
715
716
717
718
 
# File 'lib/minitest/unit.rb', line 714

def self.plugins
  @@plugins ||= (["run_tests"] +
                 public_instance_methods(false).
                 grep(/^run_/).map { |s| s.to_s }).uniq
end

.runner ⇒ Object

Returns the MiniTest::Unit subclass instance that will be used to run the tests. A MiniTest::Unit instance is the default runner.



707
708
709
 
# File 'lib/minitest/unit.rb', line 707

def self.runner
  @@runner ||= self.new
end

.runner=(runner) ⇒ Object

Tells MiniTest::Unit to delegate to runner, an instance of a MiniTest::Unit subclass, when MiniTest::Unit#run is called.



698
699
700
 
# File 'lib/minitest/unit.rb', line 698

def self.runner= runner
  @@runner = runner
end

Instance Method Details

#_run(args = []) ⇒ Object

Top level driver, controls all output and filtering.



890
891
892
893
894
895
896
897
898
899
900
901
902
903
 
# File 'lib/minitest/unit.rb', line 890

def _run args = []
  self.options = process_args args

  puts "Run options: #{help}"

  self.class.plugins.each do |plugin|
    send plugin
    break unless report.empty?
  end

  return failures + errors if @test_count > 0 # or return nil...
rescue Interrupt
  abort 'Interrupted'
end

#_run_anything(type) ⇒ Object 



732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
 
# File 'lib/minitest/unit.rb', line 732

def _run_anything type
  suites = TestCase.send "#{type}_suites"
  return if suites.empty?

  start = Time.now

  puts
  puts "# Running #{type}s:"
  puts

  @test_count, @assertion_count = 0, 0
  sync = output.respond_to? :"sync=" # stupid emacs
  old_sync, output.sync = output.sync, true if sync

  results = _run_suites suites, type

  @test_count      = results.inject(0) { |sum, (tc, _)| sum + tc }
  @assertion_count = results.inject(0) { |sum, (_, ac)| sum + ac }

  output.sync = old_sync if sync

  t = Time.now - start

  puts
  puts
  puts "Finished #{type}s in %.6fs, %.4f tests/s, %.4f assertions/s." %
    [t, test_count / t, assertion_count / t]

  report.each_with_index do |msg, i|
    puts "\n%3d) %s" % [i + 1, msg]
  end

  puts

  status
end

#_run_suite(suite, type) ⇒ Object 



773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
 
# File 'lib/minitest/unit.rb', line 773

def _run_suite suite, type
  header = "#{type}_suite_header"
  puts send(header, suite) if respond_to? header

  filter = options[:filter] || '/./'
  filter = Regexp.new $1 if filter =~ /\/(.*)\//

  assertions = suite.send("#{type}_methods").grep(filter).map { |method|
    inst = suite.new method
    inst._assertions = 0

    print "#{suite}##{method} = " if @verbose

    @start_time = Time.now
    result = inst.run self
    time = Time.now - @start_time

    print "%.2f s = " % time if @verbose
    print result
    puts if @verbose

    inst._assertions
  }

  return assertions.size, assertions.inject(0) { |sum, n| sum + n }
end

#_run_suites(suites, type) ⇒ Object 



769
770
771
 
# File 'lib/minitest/unit.rb', line 769

def _run_suites suites, type
  suites.map { |suite| _run_suite suite, type }
end

#benchmark_suite_header(suite) ⇒ Object

:nodoc:



17
18
19
 
# File 'lib/minitest/benchmark.rb', line 17

def benchmark_suite_header suite # :nodoc:
  "\n#{suite}\t#{suite.bench_range.join("\t")}"
end

#location(e) ⇒ Object

:nodoc:



800
801
802
803
804
805
806
807
 
# File 'lib/minitest/unit.rb', line 800

def location e # :nodoc:
  last_before_assertion = ""
  e.backtrace.reverse_each do |s|
    break if s =~ /in .(assert|refute|flunk|pass|fail|raise|must|wont)/
    last_before_assertion = s
  end
  last_before_assertion.sub(/:in .*$/, '')
end

#output ⇒ Object 



720
721
722
 
# File 'lib/minitest/unit.rb', line 720

def output
  self.class.output
end

#print(*a) ⇒ Object

:nodoc:



728
729
730
 
# File 'lib/minitest/unit.rb', line 728

def print *a # :nodoc:
  output.print(*a)
end

#process_args(args = []) ⇒ Object 



837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
 
# File 'lib/minitest/unit.rb', line 837

def process_args args = []
  options = {}
  orig_args = args.dup

  OptionParser.new do |opts|
    opts.banner  = 'minitest options:'
    opts.version = MiniTest::Unit::VERSION

    opts.on '-h', '--help', 'Display this help.' do
      puts opts
      exit
    end

    opts.on '-s', '--seed SEED', Integer, "Sets random seed" do |m|
      options[:seed] = m.to_i
    end

    opts.on '-v', '--verbose', "Verbose. Show progress processing files." do
      options[:verbose] = true
    end

    opts.on '-n', '--name PATTERN', "Filter test names on pattern." do |a|
      options[:filter] = a
    end

    opts.parse! args
    orig_args -= args
  end

  unless options[:seed] then
    srand
    options[:seed] = srand % 0xFFFF
    orig_args << "--seed" << options[:seed].to_s
  end

  srand options[:seed]

  self.verbose = options[:verbose]
  @help = orig_args.map { |s| s =~ /[\s|&<>$()]/ ? s.inspect : s }.join " "

  options
end

#puke(klass, meth, e) ⇒ Object

Writes status for failed test meth in klass which finished with exception e



813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
 
# File 'lib/minitest/unit.rb', line 813

def puke klass, meth, e
  e = case e
      when MiniTest::Skip then
        @skips += 1
        return "S" unless @verbose
        "Skipped:\n#{meth}(#{klass}) [#{location e}]:\n#{e.message}\n"
      when MiniTest::Assertion then
        @failures += 1
        "Failure:\n#{meth}(#{klass}) [#{location e}]:\n#{e.message}\n"
      else
        @errors += 1
        bt = MiniTest::filter_backtrace(e.backtrace).join "\n    "
        "Error:\n#{meth}(#{klass}):\n#{e.class}: #{e.message}\n    #{bt}\n"
      end
  @report << e
  e[0, 1]
end

#puts(*a) ⇒ Object

:nodoc:



724
725
726
 
# File 'lib/minitest/unit.rb', line 724

def puts *a  # :nodoc:
  output.puts(*a)
end

#run(args = []) ⇒ Object

Begins the full test run. Delegates to runner's #_run method.



883
884
885
 
# File 'lib/minitest/unit.rb', line 883

def run args = []
  self.class.runner._run(args)
end

#run_benchmarks ⇒ Object

:nodoc:



13
14
15
 
# File 'lib/minitest/benchmark.rb', line 13

def run_benchmarks # :nodoc:
  _run_anything :benchmark
end

#run_tests ⇒ Object

Runs test suites matching filter.



908
909
910
 
# File 'lib/minitest/unit.rb', line 908

def run_tests
  _run_anything :test
end

#status(io = self.output) ⇒ Object

Writes status to io



915
916
917
918
 
# File 'lib/minitest/unit.rb', line 915

def status io = self.output
  format = "%d tests, %d assertions, %d failures, %d errors, %d skips"
  io.puts format % [test_count, assertion_count, failures, errors, skips]
end