Class: ParallelTests::Test::Runner

Inherits:
Object
  • Object
show all
Defined in:
lib/parallel_tests/test/runner.rb

Direct Known Subclasses

Gherkin::Runner, RSpec::Runner

Constant Summary collapse

RuntimeLogTooSmallError = 
Class.new(StandardError)

Class Method Summary collapse

Class Method Details

.command_with_seed(cmd, seed) ⇒ Object

remove old seed and add new seed



144
145
146
147
 
# File 'lib/parallel_tests/test/runner.rb', line 144

def command_with_seed(cmd, seed)
  clean = remove_command_arguments(cmd, '--seed')
  [*clean, '--seed', seed]
end

.default_test_folder ⇒ Object 



21
22
23
 
# File 'lib/parallel_tests/test/runner.rb', line 21

def default_test_folder
  "test"
end

.execute_command(cmd, process_number, num_processes, options) ⇒ Object 



80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
 
# File 'lib/parallel_tests/test/runner.rb', line 80

def execute_command(cmd, process_number, num_processes, options)
  number = test_env_number(process_number, options).to_s
  env = (options[:env] || {}).merge(
    "TEST_ENV_NUMBER" => number,
    "PARALLEL_TEST_GROUPS" => num_processes.to_s,
    "PARALLEL_PID_FILE" => ParallelTests.pid_file_path
  )
  cmd = ["nice", *cmd] if options[:nice]

  # being able to run with for example `-output foo-$TEST_ENV_NUMBER` worked originally and is convenient
  cmd = cmd.map { |c| c.gsub("$TEST_ENV_NUMBER", number).gsub("${TEST_ENV_NUMBER}", number) }

  print_command(cmd, env) if report_process_command?(options) && !options[:serialize_stdout]

  execute_command_and_capture_output(env, cmd, options)
end

.execute_command_and_capture_output(env, cmd, options) ⇒ Object 



102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
 
# File 'lib/parallel_tests/test/runner.rb', line 102

def execute_command_and_capture_output(env, cmd, options)
  popen_options = {} # do not add `pgroup: true`, it will break `binding.irb` inside the test
  popen_options[:err] = [:child, :out] if options[:combine_stderr]

  pid = nil
  output = IO.popen(env, cmd, popen_options) do |io|
    pid = io.pid
    ParallelTests.pids.add(pid)
    capture_output(io, env, options)
  end
  ParallelTests.pids.delete(pid) if pid
  exitstatus = $?.exitstatus
  seed = output[/seed (\d+)/, 1]

  output = "#{Shellwords.shelljoin(cmd)}\n#{output}" if report_process_command?(options) && options[:serialize_stdout]

  { env: env, stdout: output, exit_status: exitstatus, command: cmd, seed: seed }
end

.find_results(test_output) ⇒ Object 



121
122
123
124
125
126
127
128
 
# File 'lib/parallel_tests/test/runner.rb', line 121

def find_results(test_output)
  test_output.lines.map do |line|
    line.chomp!
    line.gsub!(/\e\[\d+m/, '') # remove color coding
    next unless line_is_result?(line)
    line
  end.compact
end

.line_is_result?(line) ⇒ Boolean

ignores other commands runner noise

Returns:

  • (Boolean) 


35
36
37
 
# File 'lib/parallel_tests/test/runner.rb', line 35

def line_is_result?(line)
  line =~ /\d+ failure(?!:)/
end

.print_command(command, env) ⇒ Object 



97
98
99
100
 
# File 'lib/parallel_tests/test/runner.rb', line 97

def print_command(command, env)
  env_str = ['TEST_ENV_NUMBER', 'PARALLEL_TEST_GROUPS'].map { |e| "#{e}=#{env[e]}" }.join(' ')
  puts [env_str, Shellwords.shelljoin(command)].compact.join(' ')
end

.run_tests(test_files, process_number, num_processes, options) ⇒ Object 



29
30
31
32
 
# File 'lib/parallel_tests/test/runner.rb', line 29

def run_tests(test_files, process_number, num_processes, options)
  require_list = test_files.map { |file| file.gsub(" ", "\\ ") }.join(" ")
  execute_command(build_command(require_list, options), process_number, num_processes, options)
end

.runtime_log ⇒ Object

— usually overwritten by other runners



13
14
15
 
# File 'lib/parallel_tests/test/runner.rb', line 13

def runtime_log
  'tmp/parallel_runtime_test.log'
end

.summarize_results(results) ⇒ Object 



138
139
140
141
 
# File 'lib/parallel_tests/test/runner.rb', line 138

def summarize_results(results)
  sums = sum_up_results(results)
  sums.sort.map { |word, number| "#{number} #{word}#{'s' if number != 1}" }.join(', ')
end

.test_env_number(process_number, options = {}) ⇒ Object 



130
131
132
133
134
135
136
 
# File 'lib/parallel_tests/test/runner.rb', line 130

def test_env_number(process_number, options = {})
  if process_number == 0 && !options[:first_is_1]
    ''
  else
    process_number + 1
  end
end

.test_file_name ⇒ Object 



25
26
27
 
# File 'lib/parallel_tests/test/runner.rb', line 25

def test_file_name
  "test"
end

.test_suffix ⇒ Object 



17
18
19
 
# File 'lib/parallel_tests/test/runner.rb', line 17

def test_suffix
  /_(test|spec).rb$/
end

.tests_in_groups(tests, num_groups, options = {}) ⇒ Object

finds all tests and partitions them into groups



42
43
44
45
 
# File 'lib/parallel_tests/test/runner.rb', line 42

def tests_in_groups(tests, num_groups, options = {})
  tests = tests_with_size(tests, options)
  Grouper.in_even_groups_by_size(tests, num_groups, options)
end

.tests_with_size(tests, options) ⇒ Object 



47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/parallel_tests/test/runner.rb', line 47

def tests_with_size(tests, options)
  tests = find_tests(tests, options)

  case options[:group_by]
  when :found
    tests.map! { |t| [t, 1] }
  when :filesize
    sort_by_filesize(tests)
  when :runtime
    sort_by_runtime(
      tests, runtimes(tests, options),
      options.merge(allowed_missing: (options[:allowed_missing_percent] || 50) / 100.0)
    )
  when nil
    # use recorded test runtime if we got enough data
    runtimes = begin
      runtimes(tests, options)
    rescue StandardError
      []
    end
    if runtimes.size * 1.5 > tests.size
      puts "Using recorded test runtime" unless options[:quiet]
      sort_by_runtime(tests, runtimes)
    else
      sort_by_filesize(tests)
    end
  else
    raise ArgumentError, "Unsupported option #{options[:group_by]}"
  end

  tests
end