Class: Minitest::Runnable

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

Overview

Represents anything “runnable”, like Test, Spec, Benchmark, or whatever you can dream up.

Subclasses of this are automatically registered and available in Runnable.runnables.

Direct Known Subclasses

Test

Constant Summary collapse

SIGNALS =

:nodoc:

Signal.list

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(name) ⇒ Runnable

:nodoc:



382
383
384
385
386
 
# File 'lib/minitest.rb', line 382

def initialize name # :nodoc:
  self.name       = name
  self.failures   = []
  self.assertions = 0
end

Instance Attribute Details

#assertions ⇒ Object

Number of assertions executed in this run.



248
249
250
 
# File 'lib/minitest.rb', line 248

def assertions
  @assertions
end

#failures ⇒ Object

An assertion raised during the run, if any.



253
254
255
 
# File 'lib/minitest.rb', line 253

def failures
  @failures
end

Class Method Details

.inherited(klass) ⇒ Object

:nodoc:



269
270
271
272
 
# File 'lib/minitest.rb', line 269

def self.inherited klass # :nodoc:
  self.runnables << klass
  super
end

.methods_matching(re) ⇒ Object

Returns all instance methods matching the pattern re.



277
278
279
 
# File 'lib/minitest.rb', line 277

def self.methods_matching re
  public_instance_methods(true).grep(re).map(&:to_s)
end

.on_signal(name, action) ⇒ Object

:nodoc:



342
343
344
345
346
347
348
349
350
351
352
353
 
# File 'lib/minitest.rb', line 342

def self.on_signal name, action # :nodoc:
  supported = SIGNALS[name]

  old_trap = trap name do
    old_trap.call if old_trap.respond_to? :call
    action.call
  end if supported

  yield
ensure
  trap name, old_trap if supported
end

.reset ⇒ Object

:nodoc:



281
282
283
 
# File 'lib/minitest.rb', line 281

def self.reset # :nodoc:
  @@runnables = []
end

.run(reporter, options = {}) ⇒ Object

Responsible for running all runnable methods in a given class, each in its own instance. Each instance is passed to the reporter to record.



292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
 
# File 'lib/minitest.rb', line 292

def self.run reporter, options = {}
  filter = options[:filter] || "/./"
  filter = Regexp.new $1 if filter =~ %r%/(.*)/%

  filtered_methods = self.runnable_methods.find_all { |m|
    filter === m || filter === "#{self}##{m}"
  }

  exclude = options[:exclude]
  exclude = Regexp.new $1 if exclude =~ %r%/(.*)/%

  filtered_methods.delete_if { |m|
    exclude === m || exclude === "#{self}##{m}"
  }

  return if filtered_methods.empty?

  with_info_handler reporter do
    filtered_methods.each do |method_name|
      run_one_method self, method_name, reporter
    end
  end
end

.run_one_method(klass, method_name, reporter) ⇒ Object

Runs a single method and has the reporter record the result. This was considered internal API but is factored out of run so that subclasses can specialize the running of an individual test. See Minitest::ParallelTest::ClassMethods for an example.



322
323
324
325
 
# File 'lib/minitest.rb', line 322

def self.run_one_method klass, method_name, reporter
  reporter.prerecord klass, method_name
  reporter.record Minitest.run_one_method(klass, method_name)
end

.runnable_methods ⇒ Object

Each subclass of Runnable is responsible for overriding this method to return all runnable methods. See #methods_matching.

Raises:

  • (NotImplementedError) 


359
360
361
 
# File 'lib/minitest.rb', line 359

def self.runnable_methods
  raise NotImplementedError, "subclass responsibility"
end

.runnables ⇒ Object

Returns all subclasses of Runnable.



366
367
368
 
# File 'lib/minitest.rb', line 366

def self.runnables
  @@runnables
end

.with_info_handler(reporter, &block) ⇒ Object

:nodoc:



327
328
329
330
331
332
333
334
335
336
337
338
 
# File 'lib/minitest.rb', line 327

def self.with_info_handler reporter, &block # :nodoc:
  handler = lambda do
    unless reporter.passed? then
      warn "Current results:"
      warn ""
      warn reporter.reporters.first
      warn ""
    end
  end

  on_signal ::Minitest.info_signal, handler, &block
end

Instance Method Details

#failure ⇒ Object

:nodoc:



378
379
380
 
# File 'lib/minitest.rb', line 378

def failure # :nodoc:
  self.failures.first
end

#marshal_dump ⇒ Object

:nodoc:



370
371
372
 
# File 'lib/minitest.rb', line 370

def marshal_dump # :nodoc:
  [self.name, self.failures, self.assertions]
end

#marshal_load(ary) ⇒ Object

:nodoc:



374
375
376
 
# File 'lib/minitest.rb', line 374

def marshal_load ary # :nodoc:
  self.name, self.failures, self.assertions = ary
end

#name ⇒ Object

Name of the run.



258
259
260
 
# File 'lib/minitest.rb', line 258

def name
  @NAME
end

#name=(o) ⇒ Object

Set the name of the run.



265
266
267
 
# File 'lib/minitest.rb', line 265

def name= o
  @NAME = o
end

#passed? ⇒ Boolean

Did this run pass?

Note: skipped runs are not considered passing, but they don’t cause the process to exit non-zero.

Returns:

  • (Boolean)

Raises:

  • (NotImplementedError) 


401
402
403
 
# File 'lib/minitest.rb', line 401

def passed?
  raise NotImplementedError, "subclass responsibility"
end

#result_code ⇒ Object

Returns a single character string to print based on the result of the run. Eg “.”, “F”, or “E”.

Raises:

  • (NotImplementedError) 


409
410
411
 
# File 'lib/minitest.rb', line 409

def result_code
  raise NotImplementedError, "subclass responsibility"
end

#run ⇒ Object

Runs a single method. Needs to return self.

Raises:

  • (NotImplementedError) 


391
392
393
 
# File 'lib/minitest.rb', line 391

def run
  raise NotImplementedError, "subclass responsibility"
end

#skipped? ⇒ Boolean

Was this run skipped? See #passed? for more information.

Returns:

  • (Boolean)

Raises:

  • (NotImplementedError) 


416
417
418
 
# File 'lib/minitest.rb', line 416

def skipped?
  raise NotImplementedError, "subclass responsibility"
end