@modern-js/plugin-testing 2.19.1 → 2.20.1-alpha.0

package/dist/js/modern/base/index.js

@@ -0,0 +1,14 @@
+import { runTest, runJest } from "./runJest";
+import { getModuleNameMapper } from "./utils";
+import { DEFAULT_RESOLVER_PATH } from "./config";
+import { TestConfigOperator } from "./config/testConfigOperator";
+import { testingHooks } from "./hook";
+export * from "./types";
+export {
+  DEFAULT_RESOLVER_PATH,
+  TestConfigOperator,
+  getModuleNameMapper,
+  runJest,
+  runTest,
+  testingHooks
+};

package/dist/js/modern/base/runJest.js

@@ -0,0 +1,102 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import yargs from "yargs/yargs";
+import { runCLI } from "jest";
+import { chalk } from "@modern-js/utils";
+import { getJestUtils, patchConfig } from "./config";
+import { debug } from "./utils";
+const buildArgv = (rawArgv, config) => __async(void 0, null, function* () {
+  const argv = yield yargs(rawArgv).argv;
+  const result = {
+    $0: argv.$0,
+    _: argv._.slice(1)
+  };
+  Object.keys(argv).forEach((key) => {
+    if (key.includes("-") || key === "_") {
+      return;
+    }
+    result[key] = argv[key];
+  });
+  if (config) {
+    result.config = JSON.stringify(config);
+  }
+  return result;
+});
+const readResultsAndExit = (result, globalConfig) => {
+  const code = !result || result.success ? 0 : globalConfig.testFailureExitCode;
+  process.on("exit", () => {
+    if (typeof code === "number" && code !== 0) {
+      process.exitCode = code;
+    }
+  });
+  if (globalConfig.forceExit) {
+    if (!globalConfig.detectOpenHandles) {
+      console.warn(
+        `${chalk.bold(
+          "Force exiting Jest: "
+        )}Have you considered using \`--detectOpenHandles\` to detect async operations that kept running after all tests finished?`
+      );
+    }
+    process.exit(code);
+  } else if (!globalConfig.detectOpenHandles) {
+    setTimeout(() => {
+      console.warn(
+        chalk.yellow.bold(
+          "Jest did not exit one second after the test run has completed.\n\n"
+        ) + chalk.yellow(
+          "This usually means that there are asynchronous operations that weren't stopped in your tests. Consider running Jest with `--detectOpenHandles` to troubleshoot this issue."
+        )
+      );
+    }, 1e3).unref();
+  }
+};
+function runJest(_0) {
+  return __async(this, arguments, function* (config, pwd = process.cwd()) {
+    try {
+      const argvConfig = yield buildArgv(process.argv.slice(2), config);
+      const { results, globalConfig } = yield runCLI(argvConfig, [pwd]);
+      readResultsAndExit(results, globalConfig);
+    } catch (e) {
+      console.error(chalk.red((e == null ? void 0 : e.stack) || e));
+      process.exit(1);
+    }
+  });
+}
+function runTest(_0, _1) {
+  return __async(this, arguments, function* (api, config, pwd = process.cwd()) {
+    process.env.NODE_ENV = "test";
+    const jestUtils = getJestUtils(config);
+    yield patchConfig(jestUtils);
+    jestUtils.setJestUserConfig();
+    const hookRunners = api.useHookRunners();
+    const testConfigOperator = yield hookRunners.jestConfig(jestUtils, {
+      onLast: (input) => input
+    });
+    const finalConfig = testConfigOperator.getFinalConfig();
+    debug("Jest config:", finalConfig);
+    yield runJest(finalConfig, pwd);
+    yield hookRunners.afterTest();
+  });
+}
+export {
+  runJest,
+  runTest
+};

package/dist/js/modern/base/utils.js

@@ -0,0 +1,66 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+import fs from "fs";
+import path from "path";
+import { createDebugger } from "@modern-js/utils";
+const debug = createDebugger("test");
+const readCompilerOptions = (pwd = process.cwd(), filename = "tsconfig.json") => {
+  let tsConfig = {};
+  let extendedCompilerOptions = {};
+  let tsconfigFile = "";
+  try {
+    const maybeTsconfigFile = path.join(pwd, filename);
+    if (fs.existsSync(maybeTsconfigFile)) {
+      tsconfigFile = maybeTsconfigFile;
+    } else {
+      tsconfigFile = require.resolve(filename);
+    }
+    ({ config: tsConfig } = require("typescript").parseConfigFileTextToJson(
+      tsconfigFile,
+      fs.readFileSync(tsconfigFile, "utf8")
+    ));
+  } catch (e) {
+    return {};
+  }
+  if (tsConfig.extends) {
+    extendedCompilerOptions = readCompilerOptions(
+      path.dirname(tsconfigFile),
+      tsConfig.extends
+    );
+  }
+  return __spreadValues(__spreadValues({}, extendedCompilerOptions), tsConfig.compilerOptions);
+};
+const getModuleNameMapper = (alias) => Object.keys(alias).reduce((memo, cur) => {
+  const aliasValue = Array.isArray(alias[cur]) ? alias[cur] : [alias[cur]];
+  const isFile = aliasValue.some((s) => s.endsWith(".js"));
+  if (cur === "@modern-js/runtime$") {
+    memo[`.+${cur}`] = aliasValue[0];
+    return memo;
+  }
+  if (isFile) {
+    memo[cur] = aliasValue[0];
+  }
+  const key = `^${cur}/(.*)$`;
+  const value = path.normalize(`${aliasValue}/$1`);
+  memo[key] = value;
+  return memo;
+}, {});
+export {
+  debug,
+  getModuleNameMapper,
+  readCompilerOptions
+};

package/dist/js/modern/cli/bff/app.js

@@ -0,0 +1,58 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { AsyncLocalStorage } from "async_hooks";
+import { Server } from "@modern-js/prod-server";
+const store = new AsyncLocalStorage();
+const isInHandler = () => Boolean(store.getStore());
+let server = null;
+const createApp = (pwd, config, plugins, routes) => __async(void 0, null, function* () {
+  if (!server) {
+    config.output.path = "./";
+    server = new Server({
+      apiOnly: true,
+      pwd,
+      config,
+      internalPlugins: plugins,
+      routes
+    });
+    yield server.init();
+  }
+  const app = server.getRequestHandler();
+  return app;
+});
+const getApp = () => {
+  if (!server) {
+    throw new Error("please createApp first");
+  }
+  return server.getRequestHandler();
+};
+const closeServer = () => __async(void 0, null, function* () {
+  if (!server) {
+    throw new Error("please createApp first");
+  }
+  yield server.close();
+});
+export {
+  closeServer,
+  createApp,
+  getApp,
+  isInHandler
+};

package/dist/js/modern/cli/bff/constant.js

@@ -0,0 +1,4 @@
+const bff_info_key = "modern_bff_info";
+export {
+  bff_info_key
+};

package/dist/js/modern/cli/bff/index.js

@@ -0,0 +1,149 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import path from "path";
+import { isApiOnly } from "@modern-js/utils";
+import {
+  getModuleNameMapper,
+  DEFAULT_RESOLVER_PATH
+} from "../../base";
+import { bff_info_key } from "./constant";
+import { isBFFProject } from "./utils";
+const setJestConfigForBFF = (_0) => __async(void 0, [_0], function* ({
+  pwd,
+  userConfig,
+  plugins,
+  routes,
+  utils
+}) {
+  var _a;
+  const bffConfig = {
+    rootDir: path.join(pwd, "./api"),
+    setupFilesAfterEnv: [require.resolve("./setup")],
+    testEnvironment: "node",
+    testMatch: [`**/api/**/*.test.[jt]s`],
+    globals: {
+      "ts-jest": {
+        diagnostics: {
+          warnOnly: true
+        }
+      },
+      [bff_info_key]: {
+        appDir: pwd,
+        modernUserConfig: userConfig,
+        plugins,
+        routes
+      }
+    }
+  };
+  const { jestConfig } = utils;
+  const alias = ((_a = userConfig == null ? void 0 : userConfig.source) == null ? void 0 : _a.alias) || {};
+  const aliasMapper = getModuleNameMapper(alias);
+  const { moduleNameMapper } = jestConfig;
+  const transform = {
+    "\\.[jt]sx?$": require.resolve("ts-jest")
+  };
+  const apiOnly = yield isApiOnly(pwd);
+  const mergedModuleNameMapper = __spreadValues(__spreadValues({}, moduleNameMapper), aliasMapper);
+  const resolver = jestConfig.resolver || DEFAULT_RESOLVER_PATH;
+  const configFields = ["coverage", "collectCoverage", "testTimeout"];
+  const commonConfig = configFields.reduce((obj, field) => {
+    if (jestConfig.hasOwnProperty(field)) {
+      obj[field] = jestConfig[field];
+    }
+    return obj;
+  }, {});
+  if (!apiOnly) {
+    utils.setJestConfig(
+      {
+        projects: [
+          __spreadValues({}, jestConfig),
+          __spreadValues({
+            transform,
+            moduleNameMapper: mergedModuleNameMapper,
+            resolver
+          }, bffConfig)
+        ]
+      },
+      {
+        force: true
+      }
+    );
+  } else {
+    utils.setJestConfig(
+      {
+        projects: [
+          __spreadValues({
+            transform,
+            moduleNameMapper: mergedModuleNameMapper,
+            resolver
+          }, bffConfig)
+        ]
+      },
+      {
+        force: true
+      }
+    );
+  }
+  utils.setJestConfig(commonConfig);
+});
+var bff_default = () => ({
+  name: "@modern-js/testing-plugin-bff",
+  setup(api) {
+    return {
+      jestConfig: (utils, next) => __async(this, null, function* () {
+        const appContext = api.useAppContext();
+        const pwd = appContext.appDirectory;
+        if (!isBFFProject(pwd)) {
+          return next(utils);
+        }
+        const userConfig = api.useResolvedConfigContext();
+        yield setJestConfigForBFF({
+          pwd,
+          userConfig,
+          routes: appContext.serverRoutes,
+          plugins: appContext.serverInternalPlugins,
+          utils
+        });
+        return next(utils);
+      })
+    };
+  }
+});
+export {
+  bff_default as default,
+  setJestConfigForBFF
+};

package/dist/js/modern/cli/bff/mockAPI.js

@@ -0,0 +1,109 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+import * as ptr from "path-to-regexp";
+import * as mockAppModule from "./app";
+const mock_replaceUrlWithParams = (url, paramValues, payload) => {
+  const keys = [];
+  ptr.pathToRegexp(url, keys);
+  const params = keys.reduce((cur, key, index) => {
+    if (paramValues[index]) {
+      cur[key.name] = paramValues[index];
+    }
+    return cur;
+  }, {});
+  const getFinalPath = ptr.compile(url, { encode: encodeURIComponent });
+  return getFinalPath(__spreadValues(__spreadValues({}, params), payload));
+};
+const mock_getParamsAndPayload = (args) => {
+  if (args.length === 0) {
+    return [[], {}];
+  }
+  const head = args[0];
+  if (typeof head === "object") {
+    return [[], head];
+  } else {
+    const latest = args[args.length - 1];
+    if (typeof latest === "object") {
+      return [args.slice(0, args.length - 1), latest];
+    } else {
+      return [args, {}];
+    }
+  }
+};
+var mockAPI_default = (mockApiInfosByFile) => {
+  const files = Object.keys(mockApiInfosByFile);
+  files.forEach((mockedFile) => {
+    jest.mock(mockedFile, () => {
+      const supertest = require("supertest");
+      return mockApiInfosByFile[mockedFile].reduce(
+        (res, info) => {
+          const module = {
+            [info.name]: (...args) => {
+              if (mockAppModule.isInHandler()) {
+                return info.handler(...args);
+              }
+              const [params, payload] = mock_getParamsAndPayload(args);
+              const { returnHttp } = module[info.name];
+              const url = mock_replaceUrlWithParams(
+                info.routePath,
+                params,
+                payload.params
+              );
+              const app = mockAppModule.getApp();
+              let test = supertest(app)[info.httpMethod.toLowerCase()](url);
+              if (payload.query) {
+                test = test.query(payload.query);
+              }
+              if (payload.body) {
+                test = test.send(payload.body);
+              }
+              if (payload.data) {
+                test = test.send(payload.data);
+              }
+              if (payload.headers) {
+                for (const name in payload.headers) {
+                  test = test.set(name, payload.headers[name]);
+                }
+              }
+              if (payload.cookies) {
+                test = test.set("Cookie", [payload.cookies]);
+              }
+              if (returnHttp) {
+                return test;
+              }
+              return test.then((value) => {
+                try {
+                  return JSON.parse(value.text);
+                } catch (e) {
+                  return value.text;
+                }
+              });
+            }
+          };
+          res[info.name] = module[info.name];
+          Object.assign(res[info.name], info.handler);
+          res.__esModule = true;
+          return res;
+        },
+        {}
+      );
+    });
+  });
+};
+export {
+  mockAPI_default as default
+};

package/dist/js/modern/cli/bff/setup.js

@@ -0,0 +1,75 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import path from "path";
+import { ApiRouter } from "@modern-js/bff-core";
+import { bff_info_key } from "./constant";
+import mockAPI from "./mockAPI";
+import { createApp, closeServer } from "./app";
+var require_setup = __commonJS({
+  "src/cli/bff/setup.ts"(exports) {
+    let uped = false;
+    const setup = () => {
+      var _a, _b;
+      if (uped) {
+        return;
+      }
+      uped = true;
+      const bff_info = global[bff_info_key];
+      const prefix = (_b = (_a = bff_info == null ? void 0 : bff_info.modernUserConfig) == null ? void 0 : _a.bff) == null ? void 0 : _b.prefix;
+      const apiRouter = new ApiRouter({
+        apiDir: path.join(bff_info.appDir, "./api"),
+        prefix
+      });
+      const apiInfos = apiRouter.getApiHandlers();
+      const apiInfosByFile = apiInfos.reduce(
+        (res, apiInfo) => {
+          if (!res[apiInfo.filename]) {
+            res[apiInfo.filename] = [];
+          }
+          res[apiInfo.filename].push(apiInfo);
+          return res;
+        },
+        {}
+      );
+      let app = null;
+      beforeAll(() => __async(exports, null, function* () {
+        if (!app) {
+          app = yield createApp(
+            bff_info.appDir,
+            bff_info.modernUserConfig,
+            bff_info.plugins,
+            bff_info.routes
+          );
+        }
+      }));
+      afterAll(() => __async(exports, null, function* () {
+        yield closeServer();
+      }));
+      mockAPI(apiInfosByFile);
+    };
+    setup();
+  }
+});
+export default require_setup();

package/dist/js/modern/cli/bff/utils/index.js

@@ -0,0 +1,37 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+import path from "path";
+import { chalk } from "@modern-js/utils";
+const isBFFProject = (pwd) => {
+  try {
+    const packageJson = require(path.join(pwd, "./package.json"));
+    const { dependencies, devDependencies } = packageJson;
+    const isBFF = Object.keys(__spreadValues(__spreadValues({}, dependencies), devDependencies)).some(
+      (dependency) => dependency.includes("plugin-bff")
+    );
+    const isMWA = Object.keys(devDependencies).some(
+      (devDependency) => devDependency.includes("app-tools")
+    );
+    return isMWA && isBFF;
+  } catch (error) {
+    console.log(chalk.red(error));
+    return false;
+  }
+};
+export {
+  isBFFProject
+};