Module: Minitest

Defined in:
opal/stdlib/minitest.rb,
opal/stdlib/minitest/mock.rb,
opal/stdlib/minitest/test.rb,
opal/stdlib/minitest/unit.rb,
opal/stdlib/minitest/parallel.rb,
opal/stdlib/minitest/benchmark.rb,
opal/stdlib/minitest/benchmark.rb,
opal/stdlib/minitest/assertions.rb,
opal/stdlib/minitest/pride_plugin.rb

Overview

:nodoc:

Defined Under Namespace

Modules: Assertions, Expectations, Guard, Parallel Classes: AbstractReporter, Assertion, BacktraceFilter, BenchSpec, Benchmark, CompositeReporter, Mock, PrideIO, PrideLOL, ProgressReporter, Reporter, Runnable, Skip, Spec, StatisticsReporter, SummaryReporter, Test, UnexpectedError, Unit

Constant Summary

VERSION =

:nodoc:

"5.5.1"
ENCS =

:nodoc:

"".respond_to? :encoding
@@after_run = 
[]

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.__run(reporter, options) ⇒ Object

Internal run method. Responsible for telling all Runnable sub-classes to run.

NOTE: this method is redefined in parallel_each.rb, which is loaded if a Runnable calls parallelize_me!.



141
142
143
144
145
146
147
148
149
150
151
152
 
# File 'opal/stdlib/minitest.rb', line 141

def self.__run reporter, options
  suites = Runnable.runnables.shuffle
  parallel, serial = suites.partition { |s| s.test_order == :parallel }

  # If we run the parallel tests before the serial tests, the parallel tests
  # could run in parallel with the serial tests. This would be bad because
  # the serial tests won't lock around Reporter#record. Run the serial tests
  # first, so that after they complete, the parallel tests will lock when
  # recording results.
  serial.map { |suite| suite.run reporter, options } +
    parallel.map { |suite| suite.run reporter, options }
end

.after_run(&block) ⇒ Object

A simple hook allowing you to run a block of code after everything is done running. Eg:

Minitest.after_run { p $debugging_info }



67
68
69
 
# File 'opal/stdlib/minitest.rb', line 67

def self.after_run &block
  @@after_run << block
end

.autorun ⇒ Object

Registers Minitest to run at process exit



45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'opal/stdlib/minitest.rb', line 45

def self.autorun
  at_exit {
    next if $! and not ($!.kind_of? SystemExit and $!.success?)

    exit_code = nil

    at_exit {
      @@after_run.reverse_each(&:call)
      exit exit_code || false
    }

    exit_code = Minitest.run ARGV
  } unless @@installed_at_exit
  @@installed_at_exit = true
end

.filter_backtrace(bt) ⇒ Object

:nodoc:



220
221
222
 
# File 'opal/stdlib/minitest.rb', line 220

def self.filter_backtrace bt # :nodoc:
  backtrace_filter.filter bt
end

.init_plugins(options) ⇒ Object

:nodoc:



71
72
73
74
75
76
 
# File 'opal/stdlib/minitest.rb', line 71

def self.init_plugins options # :nodoc:
  self.extensions.each do |name|
    msg = "plugin_#{name}_init"
    send msg, options if self.respond_to? msg
  end
end

.load_plugins ⇒ Object

:nodoc:



78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
 
# File 'opal/stdlib/minitest.rb', line 78

def self.load_plugins # :nodoc:
  # return unless self.extensions.empty?
  #
  # seen = {}
  #
  # require "rubygems" unless defined? Gem
  #
  # Gem.find_files("minitest/*_plugin.rb").each do |plugin_path|
  #   name = File.basename plugin_path, "_plugin.rb"
  #
  #   next if seen[name]
  #   seen[name] = true
  #
  #   require plugin_path
  #   self.extensions << name
  # end
end

.plugin_pride_init(options) ⇒ Object

:nodoc:



10
11
12
13
14
15
16
17
18
19
 
# File 'opal/stdlib/minitest/pride_plugin.rb', line 10

def self.plugin_pride_init options # :nodoc:
  if PrideIO.pride? then
    klass = ENV["TERM"] =~ /^xterm|-256color$/ ? PrideLOL : PrideIO
    io    = klass.new options[:io]

    self.reporter.reporters.grep(Minitest::Reporter).each do |rep|
      rep.io = io
    end
  end
end

.plugin_pride_options(opts, options) ⇒ Object

:nodoc:



4
5
6
7
8
 
# File 'opal/stdlib/minitest/pride_plugin.rb', line 4

def self.plugin_pride_options opts, options # :nodoc:
  opts.on "-p", "--pride", "Pride. Show your testing pride!" do
    PrideIO.pride!
  end
end

.process_args(args = []) ⇒ Object

:nodoc:



154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
 
# File 'opal/stdlib/minitest.rb', line 154

def self.process_args args = [] # :nodoc:
  options = {
             :io => $stdout,
            }
  orig_args = args.dup

  OptionParser.new do |opts|
    opts.banner  = "minitest options:"
    opts.version = Minitest::VERSION

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

    desc = "Sets random seed. Also via env. Eg: SEED=n rake"
    opts.on "-s", "--seed SEED", Integer, desc 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 run on /pattern/ or string." do |a|
      options[:filter] = a
    end

    unless extensions.empty?
      opts.separator ""
      opts.separator "Known extensions: #{extensions.join(', ')}"

      extensions.each do |meth|
        msg = "plugin_#{meth}_options"
        send msg, opts, options if self.respond_to?(msg)
      end
    end

    begin
      opts.parse! args
    rescue OptionParser::InvalidOption => e
      puts
      puts e
      puts
      puts opts
      exit 1
    end

    orig_args -= args
  end unless args.empty?

  unless options[:seed] then
    srand
    options[:seed] = (ENV["SEED"] || srand).to_i % 0xFFFF
    orig_args << "--seed" << options[:seed].to_s
  end

  srand options[:seed]

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

  options
end

.run(args = []) ⇒ Object

This is the top-level run method. Everything starts from here. It tells each Runnable sub-class to run, and each of those are responsible for doing whatever they do.

The overall structure of a run looks like this:

Minitest.autorun Minitest.run(args) Minitest.__run(reporter, options) Runnable.runnables.each runnable.run(reporter, options) self.runnable_methods.each self.run_one_method(self, runnable_method, reporter) Minitest.run_one_method(klass, runnable_method, reporter) klass.new(runnable_method).run



113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
 
# File 'opal/stdlib/minitest.rb', line 113

def self.run args = []
  self.load_plugins

  options = process_args args

  reporter = CompositeReporter.new
  reporter << SummaryReporter.new(options[:io], options)
  reporter << ProgressReporter.new(options[:io], options)

  self.reporter = reporter # this makes it available to plugins
  self.init_plugins options
  self.reporter = nil # runnables shouldn't depend on the reporter, ever

  reporter.start
  __run reporter, options
  self.parallel_executor.shutdown
  reporter.report

  reporter.passed?
end

.run_one_method(klass, method_name) ⇒ Object

:nodoc:



773
774
775
776
777
 
# File 'opal/stdlib/minitest.rb', line 773

def self.run_one_method klass, method_name # :nodoc:
  result = klass.new(method_name).run
  raise "#{klass}#run _must_ return self" unless klass === result
  result
end

Instance Method Details

#attr_accessor ⇒ Object

Names of known extension plugins.



22
 
# File 'opal/stdlib/minitest.rb', line 22

mc.send :attr_accessor, :parallel_executor