babel/scripts/run_flow_tests.js

"use strict";

const path = require("path");
const chalk = require("chalk");
const parse = require("..").parse;

const flowDirectory = path.join(__dirname, "../build/flow");
const hardcodedTestFile = path.join(flowDirectory, "src/parser/test/hardcoded_tests.js");

const hardcodedTests = require(hardcodedTestFile).sections;
const options = {
  plugins: [
    "jsx",
    "flow",
    "asyncGenerators",
    "objectRestSpread"
  ],
  sourceType: "module",
};

const flowOptionsMapping = {
  "esproposal_class_instance_fields": "classProperties",
  "esproposal_class_static_fields": "classProperties",
  "esproposal_export_star_as": "exportExtensions",
  "esproposal_decorators": "decorators",
};

let failedTests = 0;
let successTests = 0;
Object.keys(hardcodedTests).forEach((sectionName) => {
  console.log("");
  console.log(`### ${sectionName} ###`);
  Object.keys(hardcodedTests[sectionName]).forEach((code) => {
    const shouldSuccess = !Object.keys(hardcodedTests[sectionName][code])
      .some(
        (key) => {
          const value = hardcodedTests[sectionName][code][key];
          if (key === "errors.length" && value === 0) return false;
          if (key === "errors" && Array.isArray(value) && value.length === 0) return false;
          if (!key.startsWith("errors")) return false;

          return true;
        }
      );

    const parserOptions = hardcodedTests[sectionName][code]["%parse_options%"];
    const babylonOptions = Object.assign({}, options );
    babylonOptions.plugins = babylonOptions.plugins.slice();

    if (parserOptions) {
      Object.keys(parserOptions).forEach((option) => {
        if (!parserOptions[option]) return;
        if (!flowOptionsMapping[option]) throw new Error("Parser options not mapped " + option);
        babylonOptions.plugins.push(flowOptionsMapping[option]);
      });
    }

    let failed = false;
    let exception = null;
    try {
      parse(code, babylonOptions);
    } catch (e) {
      exception = e;
      failed = true;
    }

    if (!failed && shouldSuccess || failed && !shouldSuccess) {
      successTests++;
      console.log(chalk.green(`✔ ${code}`));
    } else {
      failedTests++;
      printErrorMessage(code, exception, shouldSuccess, hardcodedTests[sectionName][code], babylonOptions)
    }
  });
});

function printErrorMessage(code, exception, shouldSuccess, data, babylonOptions) {
  console.log(chalk.red(`✘ ${code}`));
  console.log(chalk.yellow(`  Should ${shouldSuccess ? "parse successfully" : `fail parsing`}, but did not`));
  if (exception) console.log(chalk.yellow(`  Failed with: \`${exception.message}\``));
  if (data["errors.0.message"]) console.log(chalk.yellow(`  Expected error message similar to: \`${data["errors.0.message"]}\``));
  console.log(chalk.yellow(`  Active plugins: ${JSON.stringify(babylonOptions.plugins)}`));

}

console.log();
console.log(chalk.green(`✔ ${successTests} tests passed`));
console.log(chalk.red(`✔ ${failedTests} tests failed`));

process.exit(failedTests > 0 ? 1 : 0);