Class: TurboTests::CLI

Inherits:

Object

• Object
• TurboTests::CLI

Defined in:

lib/turbo_tests/cli.rb

Instance Method Summary

• #initialize(argv) ⇒ CLI constructor

  A new instance of CLI.

• #run ⇒ Object

Constructor Details

#initialize(argv) ⇒ CLI

Returns a new instance of CLI.

# File 'lib/turbo_tests/cli.rb', line 7

def initialize(argv)
  @argv = argv
end

Instance Method Details

#run ⇒ Object

# File 'lib/turbo_tests/cli.rb', line 11

def run
  handle_shim_command if shim_command?
  handle_fan_command if fan_command?

  requires = []
  formatters = []
  tags = []
  count = nil
  runtime_log = nil
  example_status_log = nil
  verbose = false
  fail_fast = nil
  seed = nil
  order = nil
  print_failed_group = false
  create = false
  nice = false
  worker_output = nil
  parallel_options = {}
  cli_args, parallel_args = split_parallel_args(@argv)

  OptionParser.new do |opts|
    opts.banner = <<~BANNER
      Run RSpec files in parallel, giving each process ENV['TEST_ENV_NUMBER'] ('1', '2', '3', ...).

      Uses `parallel_tests` to split files into groups, then reports RSpec results incrementally.

      Source code of `turbo_tests2` gem is based on Discourse and RubyGems work in this area (see README file of the source repository).

      Usage: turbo_tests2 [options]

      [optional] Only selected files & folders:
        turbo_tests2 spec/bar spec/baz/xxx_spec.rb

      Options:
    BANNER

    opts.on(
      "-n [PROCESSES]",
      "--count [PROCESSES]",
      Integer,
      "How many processes to use, default: available CPUs"
    ) do |n|
      count = n
    end

    opts.on("-w [PROCESSES]", "--workers [PROCESSES]", Integer, "Alias for -n, --count") do |n|
      count = n
    end

    opts.on("-r", "--require PATH", "Require a file.") do |filename|
      requires << filename
    end

    opts.on(
      "-f",
      "--format FORMATTER",
      "Choose a formatter. Available formatters: progress (p), documentation (d). Default: progress"
    ) do |name|
      formatters << {
        name: name,
        outputs: []
      }
    end

    opts.on("-t", "--tag TAG", "Run examples with the specified tag.") do |tag|
      tags << tag
    end

    opts.on("-o", "--out FILE", "Write output to a file instead of $stdout") do |filename|
      if formatters.empty?
        formatters << {
          name: "progress",
          outputs: []
        }
      end
      formatters.last[:outputs] << filename
    end

    opts.on("--runtime-log FILE", "Location of previously recorded test runtimes") do |filename|
      runtime_log = filename
    end

    opts.on("--example-status-log FILE", "Use RSpec example status persistence timings for grouping") do |filename|
      example_status_log = filename
    end

    opts.on("--pattern PATTERN", "Run spec files matching this regex pattern") do |pattern|
      parallel_options[:pattern] = compile_pattern(pattern)
    end

    opts.on("--exclude-pattern PATTERN", "Exclude spec files matching this regex pattern") do |pattern|
      parallel_options[:exclude_pattern] = compile_pattern(pattern)
    end

    opts.on("--only-group GROUP_INDEX[,GROUP_INDEX]", "Run only the selected 1-based parallel_tests group index(es)") do |groups|
      parallel_options[:only_group] = parse_only_groups(groups)
    end

    opts.on("--group-by MODE", "Group files by runtime, filesize, or found order") do |mode|
      parallel_options[:group_by] = parse_group_by(mode)
    end

    opts.on("--allowed-missing PERCENT", Integer, "Allowed percentage of missing runtimes for runtime grouping") do |percent|
      parallel_options[:allowed_missing_percent] = parse_allowed_missing(percent)
    end

    opts.on("--unknown-runtime SECONDS", Float, "Runtime in seconds to assign files missing runtime history") do |seconds|
      parallel_options[:unknown_runtime] = parse_unknown_runtime(seconds)
    end

    opts.on("-v", "--verbose", "More output") do
      verbose = true
    end

    opts.on(
      "--worker-output MODE",
      "Raw worker output mode: warnings, stream, buffered, or quiet; env: TURBO_TESTS2_WORKER_OUTPUT"
    ) do |mode|
      worker_output = mode
    end

    opts.on("--fail-fast=[N]") do |n|
      n = begin
        Integer(n)
      rescue
        nil
      end
      fail_fast = (n.nil? || n < 1) ? 1 : n
    end

    opts.on("--seed SEED", "Seed for RSpec") do |s|
      seed = s
    end

    opts.on("--order ORDER", "RSpec example order: random (default) or defined") do |value|
      order = value
    end

    opts.on("--no-random", "Run examples in defined order without passing a seed") do
      order = "defined"
    end

    opts.on("--create", "Create databases") do
      create = true
    end

    opts.on("--print_failed_group", "Prints group that had failures in it") do
      print_failed_group = true
    end

    opts.on("--nice", "execute test commands with low priority") do
      nice = true
    end
  end.parse!(cli_args)

  parse_parallel_args(parallel_args, parallel_options) unless parallel_args.empty?

  if create
    return TurboTests::Runner.create(count)
  end

  requires.each { |f| require(f) }

  if formatters.empty?
    formatters << {
      name: "progress",
      outputs: []
    }
  end

  formatters.each do |formatter|
    formatter[:outputs] << "-" if formatter[:outputs].empty?
  end

  load_rake

  invoke_rake_hook("setup")

  files = cli_args.empty? ? nil : cli_args

  exitstatus = TurboTests::Runner.run(
    formatters: formatters,
    tags: tags,
    files: files,
    runtime_log: runtime_log,
    example_status_log: example_status_log,
    verbose: verbose,
    fail_fast: fail_fast,
    count: count,
    seed: seed,
    order: order,
    nice: nice,
    print_failed_group: print_failed_group,
    worker_output: worker_output,
    parallel_options: parallel_options
  )

  invoke_rake_hook("cleanup")

  # From https://github.com/galtzo-floss/turbo_tests2/pull/20/
  exit(exitstatus)
end