Class: LeftRight::Runner

Inherits:
Test::Unit::UI::Console::TestRunner
  • Object
show all
Defined in:
lib/leftright/runner.rb

Instance Method Summary collapse

Instance Method Details

#add_fault(fault) ⇒ Object

We intercept this to be able to set some pertinent state, as well as change all remaining test methods in the current class to just skip, since we already failed once at this point.



25
26
27
28
29
30
 
# File 'lib/leftright/runner.rb', line 25

def add_fault(fault)
  lr.state.fault = fault
  lr.skip_testing_class lr.state.class

  super
end

#finished(elapsed_time) ⇒ Object

This prints the final summary at the end of all tests.



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
 
# File 'lib/leftright/runner.rb', line 74

def finished(elapsed_time)
  passed_count = @result.run_count     -
                 @result.failure_count -
                 @result.error_count   - lr.state.skipped_count

  total = { :passed  => passed_count,
            :failed  => @result.failure_count,
            :errors  => @result.error_count,
            :tests   => @result.run_count,
            :skipped => lr.state.skipped_count }

  results = []

  unless passed_count.zero?
    total[:passed] = 'all' if passed_count == @result.run_count
    results << lr::C.green("#{total[:passed]} passed")
  end

  unless lr.state.skipped_count.zero?
    results << lr::C.cyan("#{total[:skipped]} skipped")
  end

  unless @result.failure_count.zero?
    results << lr::C.red("#{total[:failed]} failed")
  end

  unless @result.error_count.zero?
    plural = @result.error_count > 1 ? 'errors' : 'error'
    results << lr::C.yellow("#{total[:errors]} #{plural}")
  end

  io.write "\n"
  io.write "\n" unless lr.state.previous_failed
  io.write "#{total[:tests]} test#{'s' if @result.run_count > 1}: "
  io.write results.join(', ').reverse.sub(',', 'dna ').reverse # :(
  io.write "\n" + "\n"
  io.puts "(#{elapsed_time} seconds)"
end

#io ⇒ Object 



113
114
115
 
# File 'lib/leftright/runner.rb', line 113

def io
  @io || @output || STDOUT
end

#lr ⇒ Object

Access to the LeftRight module from the Runner instance. Hopefully to reduce the likelyhood of future name clashes.



8
9
10
 
# File 'lib/leftright/runner.rb', line 8

def lr
  LeftRight
end

#output_single(captured, *etc) ⇒ Object

Test::Unit uses this method to print ‘.’, ‘F’, ‘E’, and possibly others. We do most of the work here, using the state saved in ‘add_fault’ and ‘test_finished’.



36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
# File 'lib/leftright/runner.rb', line 36

def output_single(captured, *etc)
  # Make sure we are printing a test result
  return super unless %w[ . F E ].include? captured

  # Do nothing if the method was a skipper
  return if lr.state.skip && '.' == captured

  output = case captured
    when '.' then lr.P
    when 'F' then lr.F
    when 'E' then lr.E
  end

  if lr.state.last_class_printed != lr.state.class
    # If we're here, we need to print a new class name on the left side
    lr.state.last_class_printed = lr.state.class
    lr.state.dots = 0
    io.write "\n"
    io.write lr.justify_left_side(
                lr.format_class_name(lr.state.class.name))
  elsif captured != '.'
    # This handles the edge case when the first test for a class fails
    io.write "\n"
    io.write lr.justify_left_side
  end

  # Justify all lines but first:
  output.gsub! "\n", "\n" + lr.justify_left_side

  io.write output
ensure # reset all of the nasty state stuff
  io.flush
  lr.state.previous_failed = captured != '.'
  lr.state.skip            = false
end

#test_started(test_name) ⇒ Object

We intercept this to be able to set some pertinent state.



14
15
16
17
18
19
 
# File 'lib/leftright/runner.rb', line 14

def test_started(test_name)
  name           = lr.extract_class_name test_name
  lr.state.class = lr.testcase_classes.detect { |c| c.name == name }

  super
end