Class: Minitest::Runnable

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

Overview

re-open

Direct Known Subclasses

Result, 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:



535
536
537
538
539
540
 
# File 'lib/minitest.rb', line 535

def initialize name # :nodoc:
  self.name       = name
  self.failures   = []
  self.assertions = 0
  # lazy initializer for metadata
end

Instance Attribute Details

#assertions ⇒ Object

Number of assertions executed in this run.



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

def assertions
  @assertions
end

#failures ⇒ Object

An assertion raised during the run, if any.



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

def failures
  @failures
end

#metadata ⇒ Object

Metadata you attach to the test results that get sent to the reporter.

Lazily initializes to a hash, to keep memory down.

NOTE: this data must be plain (read: marshal-able) data! Hashes! Arrays! Strings!



550
551
552
 
# File 'lib/minitest.rb', line 550

def metadata
  @metadata ||= {}
end

#time ⇒ Object

The time it took to run.



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

def time
  @time
end

Class Method Details

.filter_runnable_methods(options = {}) ⇒ Object

Returns an array of filtered runnable_methods. Uses options (--include arguments) and options (--exclude arguments) values to filter.



434
435
436
437
438
439
440
441
442
443
444
445
 
# File 'lib/minitest.rb', line 434

def self.filter_runnable_methods options={}
  pos = options[:include]
  neg = options[:exclude]

  pos = Regexp.new $1 if pos.kind_of?(String) && pos =~ %r%/(.*)/%
  neg = Regexp.new $1 if neg.kind_of?(String) && neg =~ %r%/(.*)/%

  # at most 1-2% slower than a 1-pass version, stop optimizing this
  self.runnable_methods
    .select { |m| !pos ||  pos === m || pos === "#{self}##{m}"  }
    .reject { |m|  neg && (neg === m || neg === "#{self}##{m}") }
end

.inherited(klass) ⇒ Object

:nodoc:



1219
1220
1221
1222
 
# File 'lib/minitest.rb', line 1219

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

.methods_matching(re) ⇒ Object

Returns all instance methods matching the pattern re.



419
420
421
 
# File 'lib/minitest.rb', line 419

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

.on_signal(name, action) ⇒ Object

:nodoc:



503
504
505
506
507
508
509
510
511
512
513
514
 
# File 'lib/minitest.rb', line 503

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:



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

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

.run_order ⇒ Object

Defines the order to run tests (:random by default). Override this or use a convenience method to change it for your tests.



493
494
495
 
# File 'lib/minitest.rb', line 493

def self.run_order
  :random
end

.runnable_methods ⇒ Object

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

Raises:

  • (NotImplementedError) 


520
521
522
 
# File 'lib/minitest.rb', line 520

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

.runnables ⇒ Object

Returns all subclasses of Runnable.



527
528
529
 
# File 'lib/minitest.rb', line 527

def self.runnables
  @@runnables
end

.with_info_handler(_reporter = nil, &block) ⇒ Object

:nodoc:



497
498
499
 
# File 'lib/minitest.rb', line 497

def self.with_info_handler _reporter=nil, &block # :nodoc:
  on_signal ::Minitest.info_signal, @_info_handler, &block
end

Instance Method Details

#failure ⇒ Object

:nodoc:



531
532
533
 
# File 'lib/minitest.rb', line 531

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

#metadata? ⇒ Boolean

Returns true if metadata exists.

Returns:

  • (Boolean) 


562
563
564
 
# File 'lib/minitest.rb', line 562

def metadata?
  defined? @metadata
end

#name ⇒ Object

Name of the run.



405
406
407
 
# File 'lib/minitest.rb', line 405

def name
  @NAME
end

#name=(o) ⇒ Object

Set the name of the run.



412
413
414
 
# File 'lib/minitest.rb', line 412

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) 


579
580
581
 
# File 'lib/minitest.rb', line 579

def passed?
  raise NotImplementedError, "subclass responsibility"
end

#result_code ⇒ Object

Returns a single character string to print based on the result of the run. One of ".", "F", "E" or "S".

Raises:

  • (NotImplementedError) 


588
589
590
 
# File 'lib/minitest.rb', line 588

def result_code
  raise NotImplementedError, "subclass responsibility"
end

#run ⇒ Object

Runs a single method. Needs to return self.

Raises:

  • (NotImplementedError) 


569
570
571
 
# File 'lib/minitest.rb', line 569

def run
  raise NotImplementedError, "subclass responsibility"
end

#skipped? ⇒ Boolean

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

Returns:

  • (Boolean)

Raises:

  • (NotImplementedError) 


595
596
597
 
# File 'lib/minitest.rb', line 595

def skipped?
  raise NotImplementedError, "subclass responsibility"
end

#time_it ⇒ Object

:nodoc:



394
395
396
397
398
399
400
 
# File 'lib/minitest.rb', line 394

def time_it # :nodoc:
  t0 = Minitest.clock_time

  yield
ensure
  self.time = Minitest.clock_time - t0
end