async function runner()

in packages/flow-dev-tools/src/record/recordRunner.js [98:246]
98 lines of code
17 McCabe index (conditional complexity)

async function runner(args: Args): Promise<void> {
  const builder = new Builder(args.errorCheckCommand);
  let suites;
  if (args.rerun != null) {
    suites = await findTestsByRun(args.rerun, true);
  } else {
    suites = await findTestsByName(args.suites);
  }

  const loadedSuites = {};
  for (const suiteName of suites) {
    loadedSuites[suiteName] = loadSuite(suiteName);
  }

  const runQueue = new RunQueue(
    args.bin,
    args.parallelism,
    false,
    loadedSuites,
    builder,
  );

  await runQueue.go();

  await builder.cleanup();

  let totalTests = 0,
    totalSteps = 0,
    testNum = 0,
    stepNum = 0,
    suiteName = 0;

  function printStatus(status: 'RECORDING' | 'RECORDED' | 'FAIL'): void {
    let statusText = chalk.bold('[ ] RECORDING:       ');
    let newline = '';
    if (status === 'RECORDED') {
      statusText = chalk.green.bold('[✓] RECORDED:        ');
      newline = '\n';
    } else if (status === 'FAIL') {
      statusText = chalk.red.bold('[✗] FAILED TO RECORD:');
      newline = '\n';
    }
    if (process.stdout.isTTY) {
      // $FlowFixMe - Add this to lib file
      process.stdout.clearLine();
      process.stdout.write(
        format(
          '\r%s  %s (%d/%d tests %d/%d steps passed)%s',
          statusText,
          suiteName,
          testNum,
          totalTests,
          stepNum,
          totalSteps,
          newline,
        ),
      );
    } else {
      if (status == 'FAIL' || status == 'RECORDED') {
        process.stdout.write(
          format(
            '%s  %s (%d/%d tests %d/%d steps passed)\n',
            statusText,
            suiteName,
            testNum,
            totalTests,
            stepNum,
            totalSteps,
          ),
        );
      }
    }
  }

  const results = runQueue.results;
  for (suiteName in results) {
    const suiteResult = results[suiteName];
    if (suiteResult.type === 'exceptional') {
      printStatus('FAIL');
      continue;
    }
    // TODO - reorder records based on line number
    totalTests = suiteResult.testResults.length;
    for (testNum = 0; testNum < totalTests; testNum++) {
      let testFailed = false;
      let testRecorded = false;
      totalSteps =
        suiteResult.testResults[totalTests - testNum - 1].stepResults.length;
      for (stepNum = 0; stepNum < totalSteps; stepNum++) {
        printStatus('RECORDING');
        // Record starting at the end to avoid messing with line numbers
        const stepResult =
          suiteResult.testResults[totalTests - testNum - 1].stepResults[
            totalSteps - stepNum - 1
          ];
        if (!stepResult.passed) {
          // Again, start with the last assertion
          for (
            let assertionNum = stepResult.assertionResults.length - 1;
            assertionNum >= 0;
            assertionNum--
          ) {
            const result = stepResult.assertionResults[assertionNum];
            if (result.type === 'fail') {
              const suggestion = result.suggestion;
              if (suggestion.method) {
                const assertLoc = result.assertLoc;
                if (assertLoc) {
                  let filename = assertLoc.filename;
                  if (!isAbsolute(filename)) {
                    filename = join(getTestsDir(), suiteName, filename);
                  }
                  const code = await readFile(filename, 'utf8');
                  const ast = parser.parse(code, {});
                  const range =
                    assertLoc &&
                    dfsForRange(ast, assertLoc.line, assertLoc.column);
                  if (range) {
                    const [start, end] = range;
                    const out =
                      code.slice(0, start) +
                      suggestionToString(suggestion, assertLoc.column) +
                      code.slice(end);
                    await writeFile(filename, out);
                  } else {
                    process.stderr.write(
                      'Could not find the assertion in the code\n',
                    );
                  }
                } else {
                  process.stderr.write(
                    'Could not find the assertion in the stack\n',
                  );
                }
              } else if (suggestion.file) {
                let filename = suggestion.file;
                if (!isAbsolute(filename)) {
                  filename = join(getTestsDir(), suiteName, filename);
                }
                await writeFile(filename, suggestion.contents);
              }
            }
          }
        }
      }
    }
    printStatus('RECORDED');
  }
}