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

Defined Under Namespace

Classes: ExitAfterFirstFail

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(name) ⇒ Runnable

:nodoc:



445
446
447
448
449
 
# File 'lib/minitest.rb', line 445

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.



284
285
286
 
# File 'lib/minitest.rb', line 284

def assertions
  @assertions
end

#failures ⇒ Object

An assertion raised during the run, if any.



289
290
291
 
# File 'lib/minitest.rb', line 289

def failures
  @failures
end

Class Method Details

.check_failures(result, reporter) ⇒ Object 



325
326
327
328
329
330
331
332
333
 
# File 'lib/minitest.rb', line 325

def self.check_failures result, reporter
  if !result.failures.empty?
    begin
      reporter.reporters.each { |r| r.report }
    ensure
      raise ExitAfterFirstFail
    end
  end
end

.inherited(klass) ⇒ Object

:nodoc:



305
306
307
308
 
# File 'lib/minitest.rb', line 305

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

.methods_matching(re) ⇒ Object

Returns all instance methods matching the pattern re.



313
314
315
 
# File 'lib/minitest.rb', line 313

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

.on_signal(name, action) ⇒ Object

:nodoc:



405
406
407
408
409
410
411
412
413
414
415
416
 
# File 'lib/minitest.rb', line 405

def self.on_signal name, action # :nodoc:
  supported = Signal.list[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:



317
318
319
 
# File 'lib/minitest.rb', line 317

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.



340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
 
# File 'lib/minitest.rb', line 340

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}"
  }

  begin
    # before_first
    method1 = self.new(filtered_methods.first)
    # run method and capture exceptions.
    method1.capture_exceptions do
      method1.before_first_method
    end
    # save exceptions to reporter and check for failures
    with_info_handler reporter do
      # only record if failures not empty, otherwise
      # the count (runs) are messed up. each call to .record
      # increases count by one.
      if !method1.failures.empty?
        reporter.record method1
        check_failures method1, reporter
      end

      # run the other methods
      filtered_methods.each do |method_name|
        result = self.new(method_name).run
        raise "#{self}#run _must_ return self" unless self === result
        reporter.record result
        check_failures result, reporter
      end
    end
  ensure # ensure after last runs
    # after_last
    # init method1 again
    method1 = self.new(filtered_methods.first)
    method1.capture_exceptions do
      method1.after_last_method
    end
    with_info_handler reporter do
      if !method1.failures.empty?
        reporter.record method1
        check_failures method1, reporter
      end
    end
  end
end

.runnable_methods ⇒ Object

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

Raises:

  • (NotImplementedError) 


422
423
424
 
# File 'lib/minitest.rb', line 422

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

.runnables ⇒ Object

Returns all subclasses of Runnable.



429
430
431
 
# File 'lib/minitest.rb', line 429

def self.runnables
  @@runnables
end

.with_info_handler(reporter, &block) ⇒ Object

:nodoc:



392
393
394
395
396
397
398
399
400
401
402
403
 
# File 'lib/minitest.rb', line 392

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 "INFO", handler, &block
end

Instance Method Details

#after_last_method ⇒ Object 



390
 
# File 'lib/minitest.rb', line 390

def after_last_method; end

#before_first_method ⇒ Object 



389
 
# File 'lib/minitest.rb', line 389

def before_first_method; end

#failure ⇒ Object

:nodoc:



441
442
443
 
# File 'lib/minitest.rb', line 441

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

#marshal_dump ⇒ Object

:nodoc:



433
434
435
 
# File 'lib/minitest.rb', line 433

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

#marshal_load(ary) ⇒ Object

:nodoc:



437
438
439
 
# File 'lib/minitest.rb', line 437

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

#name ⇒ Object

Name of the run.



294
295
296
 
# File 'lib/minitest.rb', line 294

def name
  @NAME
end

#name=(o) ⇒ Object

Set the name of the run.



301
302
303
 
# File 'lib/minitest.rb', line 301

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) 


464
465
466
 
# File 'lib/minitest.rb', line 464

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) 


472
473
474
 
# File 'lib/minitest.rb', line 472

def result_code
  raise NotImplementedError, "subclass responsibility"
end

#run ⇒ Object

Runs a single method. Needs to return self.

Raises:

  • (NotImplementedError) 


454
455
456
 
# File 'lib/minitest.rb', line 454

def run
  raise NotImplementedError, "subclass responsibility"
end

#skipped? ⇒ Boolean

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

Returns:

  • (Boolean)

Raises:

  • (NotImplementedError) 


479
480
481
 
# File 'lib/minitest.rb', line 479

def skipped?
  raise NotImplementedError, "subclass responsibility"
end