@akanjs/test 0.0.54 → 0.0.55

package/index.mjs

@@ -0,0 +1 @@
+export * from "./src";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/test",
-  "version": "0.0.54",
+  "version": "0.0.55",
   "type": "commonjs",
   "publishConfig": {
     "access": "public"
@@ -24,5 +24,11 @@
     "mongoose": "^8.9.3",
     "redis-memory-server": "^0.11.0",
     "tsconfig-paths": "^4.2.0"
+  },
+  "exports": {
+    ".": {
+      "require": "./index.js",
+      "import": "./index.mjs"
+    }
   }
 }

package/src/index.mjs

@@ -0,0 +1,6 @@
+import { sampleOf } from "./sampleOf";
+import { sample } from "./sample";
+export {
+  sample,
+  sampleOf
+};

package/src/jest.config.base.mjs

@@ -0,0 +1,33 @@
+import { config } from "dotenv";
+const withBase = (name) => {
+  config();
+  process.env.NEXT_PUBLIC_ENV = "testing";
+  process.env.NEXT_PUBLIC_OPERATION_MODE = "local";
+  process.env.NEXT_PUBLIC_APP_NAME = name;
+  process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+  const akanjsPrefix = process.env.USE_AKANJS_PKGS === "true" ? "../../pkgs/" : "";
+  return {
+    displayName: name,
+    resolver: "@nx/jest/plugins/resolver",
+    globalSetup: `${akanjsPrefix}@akanjs/test/src/jest.globalSetup.ts`,
+    setupFilesAfterEnv: [`${akanjsPrefix}@akanjs/test/src/jest.setupFilesAfterEnv.ts`],
+    globalTeardown: `${akanjsPrefix}@akanjs/test/src/jest.globalTeardown.ts`,
+    testMatch: ["**/?(*.)+(test).ts?(x)"],
+    testPathIgnorePatterns: ["/node_modules/", "/app/"],
+    maxWorkers: 1,
+    transform: {
+      "signal\\.(test)\\.ts$": ["ts-jest", { tsconfig: "<rootDir>/tsconfig.spec.json" }],
+      "^.+\\.(ts|js|html)$": ["ts-jest", { tsconfig: "<rootDir>/tsconfig.spec.json" }]
+    },
+    moduleFileExtensions: ["ts", "tsx", "js", "jsx"],
+    coverageDirectory: `../../coverage/libs/${name}`,
+    coverageReporters: ["html"],
+    testEnvironment: "node",
+    testEnvironmentOptions: {
+      customExportConditions: ["node", "require", "default"]
+    }
+  };
+};
+export {
+  withBase
+};

package/src/jest.globalSetup.mjs

@@ -0,0 +1,19 @@
+import "tsconfig-paths/register";
+import { TestServer } from "./jest.testServer";
+const setup = async (globalConfig, projectConfig) => {
+  const { env } = require(`${globalConfig.rootDir}/env/env.server.testing`);
+  const { fetch, registerModules } = require(`${globalConfig.rootDir}/server`);
+  const maxWorkers = globalConfig.maxWorkers;
+  if (!maxWorkers)
+    throw new Error("maxWorkers is not defined");
+  const testServers = new Array(maxWorkers).fill(0).map((_, idx) => new TestServer(registerModules, env, idx + 1));
+  await Promise.all(testServers.map((server) => server.init()));
+  global.__TEST_SERVERS__ = testServers;
+  global.fetch = fetch;
+  global.env = env;
+  global.registerModules = registerModules;
+};
+var jest_globalSetup_default = setup;
+export {
+  jest_globalSetup_default as default
+};

package/src/jest.globalTeardown.mjs

@@ -0,0 +1,11 @@
+import "tsconfig-paths/register";
+const teardown = async (globalConfig, projectConfig) => {
+  const testServers = global.__TEST_SERVERS__;
+  if (!testServers)
+    throw new Error("Test servers are not defined");
+  await Promise.all(testServers.map((server) => server.terminate()));
+};
+var jest_globalTeardown_default = teardown;
+export {
+  jest_globalTeardown_default as default
+};

package/src/jest.setupFilesAfterEnv.mjs

@@ -0,0 +1,19 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+import { TestServer } from "./jest.testServer";
+var require_jest_setupFilesAfterEnv = __commonJS({
+  "pkgs/@akanjs/test/src/jest.setupFilesAfterEnv.ts"() {
+    const { env, fetch } = global;
+    jest.setTimeout(3e4);
+    global.beforeAll(async () => {
+      TestServer.initClient(env);
+      await fetch.cleanup();
+    });
+    global.afterAll(async () => {
+      await fetch.client.terminate();
+    });
+  }
+});
+export default require_jest_setupFilesAfterEnv();

package/src/jest.testServer.mjs

@@ -0,0 +1,106 @@
+import { Logger, sleep } from "@akanjs/common";
+import { createNestApp } from "@akanjs/server";
+import { client } from "@akanjs/signal";
+import { MongoMemoryServer } from "mongodb-memory-server";
+import mongoose from "mongoose";
+import { RedisMemoryServer } from "redis-memory-server";
+const MAX_RETRY = 5;
+const TEST_LISTEN_PORT_BASE = 38080;
+const TEST_MONGODB_PORT_BASE = 38081;
+const TEST_REDIS_PORT_BASE = 38082;
+const MIN_ACTIVATION_TIME = 0;
+const MAX_ACTIVATION_TIME = 3e4;
+class TestServer {
+  #logger = new Logger("TestServer");
+  #mongod;
+  #redis;
+  #registerModules;
+  #env;
+  workerId;
+  #startAt = Date.now();
+  #app;
+  #portOffset = 0;
+  static initClient(env, workerId = parseInt(process.env.JEST_WORKER_ID ?? "0")) {
+    if (workerId === 0)
+      throw new Error("TestClient should not be used in main thread");
+    const portOffset = workerId * 1e3 + env.appCode * 10;
+    const port = TEST_LISTEN_PORT_BASE + portOffset;
+    const endpoint = `http://localhost:${port}/backend/graphql`;
+    client.init({ uri: endpoint });
+  }
+  constructor(registerModules, env, workerId) {
+    this.workerId = workerId ?? parseInt(process.env.JEST_WORKER_ID ?? "0");
+    if (this.workerId === 0)
+      throw new Error("TestServer should not be used in main thread");
+    this.#portOffset = this.workerId * 1e3 + env.appCode * 10;
+    this.#mongod = new MongoMemoryServer({ instance: { port: TEST_MONGODB_PORT_BASE + this.#portOffset } });
+    this.#redis = new RedisMemoryServer({ instance: { port: TEST_REDIS_PORT_BASE + this.#portOffset } });
+    this.#env = { ...env };
+    this.#registerModules = registerModules;
+  }
+  async init() {
+    for (let i = 0; i < MAX_RETRY; i++) {
+      try {
+        const watchdog = setTimeout(() => {
+          throw new Error("TestServer Init Timeout");
+        }, MAX_ACTIVATION_TIME);
+        await this.#init();
+        clearTimeout(watchdog);
+        return;
+      } catch (e) {
+        this.#logger.error(e);
+        await this.terminate();
+      }
+    }
+  }
+  async #init() {
+    const now = Date.now();
+    this.#logger.log(`Test System #${this.workerId} Initializing...`);
+    const port = TEST_LISTEN_PORT_BASE + this.#portOffset;
+    const [mongoUri, redisHost, redisPort] = await Promise.all([
+      this.startMongo(),
+      this.#redis.getHost(),
+      this.#redis.getPort()
+    ]);
+    this.#env.port = port;
+    this.#env.mongoUri = mongoUri;
+    this.#env.redisUri = `redis://${redisHost}:${redisPort}`;
+    this.#env.meiliUri = "http://localhost:7700/search";
+    this.#env.onCleanup = async () => {
+      await this.cleanup();
+    };
+    this.#app = await createNestApp({ registerModules: this.#registerModules, env: this.#env });
+    this.#logger.log(`Test System #${this.workerId} Initialized, Mongo: ${mongoUri}, Redis: ${redisHost}:${redisPort}`);
+    this.#startAt = Date.now();
+    this.#logger.log(`Test System #${this.workerId} Activation Time: ${this.#startAt - now}ms`);
+  }
+  async startMongo() {
+    await this.#mongod.start();
+    return this.#mongod.getUri();
+  }
+  async cleanup() {
+    const now = Date.now();
+    this.#logger.log("Mongo Memory Database Cleaning up...");
+    if (this.#mongod.state === "running") {
+      await this.#mongod.stop();
+      await this.#mongod.start(true);
+    }
+    this.#logger.log(`Mongo Memory Database Cleaned up in ${Date.now() - now}ms`);
+  }
+  async terminate() {
+    const now = Date.now();
+    const elapsed = now - this.#startAt;
+    await sleep(50);
+    client.io?.socket.close();
+    await this.#app.close();
+    if (elapsed < MIN_ACTIVATION_TIME) {
+      this.#logger.log(`waiting for ${MIN_ACTIVATION_TIME - elapsed}`);
+      await sleep(MIN_ACTIVATION_TIME - elapsed);
+    }
+    await Promise.all([mongoose.disconnect(), this.#mongod.stop(), this.#redis.stop()]);
+    this.#logger.log(`System Terminated in ${Date.now() - now}ms`);
+  }
+}
+export {
+  TestServer
+};

package/src/playwright.config.base.mjs

@@ -0,0 +1,57 @@
+import { workspaceRoot } from "@nx/devkit";
+import { nxE2EPreset } from "@nx/playwright/preset";
+import { defineConfig, devices } from "@playwright/test";
+const baseURL = process.env.BASE_URL ?? "http://127.0.0.1:4200";
+const projectName = process.env.NEXT_PUBLIC_APP_NAME ?? "unknown";
+const withBase = (filename, config = {}) => defineConfig({
+  ...nxE2EPreset(filename, { testDir: "./app" }),
+  /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
+  use: {
+    baseURL,
+    /* Collect trace when retrying the failed test. See https://playwright.dev/docs/trace-viewer */
+    trace: "on-first-retry"
+  },
+  /* Run your local dev server before starting the tests */
+  webServer: {
+    command: `nx serve ${projectName}`,
+    url: "http://127.0.0.1:4200",
+    reuseExistingServer: !process.env.CI,
+    cwd: workspaceRoot
+  },
+  projects: [
+    {
+      name: "chromium",
+      use: { ...devices["Desktop Chrome"] }
+    },
+    {
+      name: "firefox",
+      use: { ...devices["Desktop Firefox"] }
+    },
+    {
+      name: "webkit",
+      use: { ...devices["Desktop Safari"] }
+    }
+    // Uncomment for mobile browsers support
+    /* {
+      name: 'Mobile Chrome',
+      use: { ...devices['Pixel 5'] },
+    },
+    {
+      name: 'Mobile Safari',
+      use: { ...devices['iPhone 12'] },
+    }, */
+    // Uncomment for branded browsers
+    /* {
+      name: 'Microsoft Edge',
+      use: { ...devices['Desktop Edge'], channel: 'msedge' },
+    },
+    {
+      name: 'Google Chrome',
+      use: { ...devices['Desktop Chrome'], channel: 'chrome' },
+    } */
+  ],
+  ...config
+});
+export {
+  withBase
+};

package/src/playwright.pageAgent.mjs

@@ -0,0 +1,42 @@
+import { test } from "@playwright/test";
+import { expect } from "@playwright/test";
+class PageAgent {
+  page;
+  #defaultWaitMs = 500;
+  #isInitialized = false;
+  constructor(page) {
+    this.page = page;
+  }
+  async goto(path) {
+    await Promise.all([this.page.goto(path), this.waitForPathChange(path)]);
+    if (!this.#isInitialized) {
+      this.#isInitialized = true;
+    }
+  }
+  async waitForPathChange(path) {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error("Timeout waiting for pathChange message"));
+      }, 3e4);
+      this.page.on("console", (msg) => {
+        if (msg.type() === "log" && msg.text().startsWith(`%cpathChange-finished:${path ?? ""}`)) {
+          clearInterval(timeout);
+          setTimeout(() => {
+            resolve(true);
+          }, this.#defaultWaitMs);
+        }
+      });
+    });
+  }
+  async wait(ms = this.#defaultWaitMs) {
+    await this.page.waitForTimeout(ms);
+  }
+  url() {
+    return "/" + this.page.url().split("/").slice(4).join("/");
+  }
+}
+export {
+  PageAgent,
+  expect,
+  test
+};

package/src/sample.mjs

@@ -0,0 +1,12 @@
+import { dayjs } from "@akanjs/base";
+import { randomPick, randomPicks } from "@akanjs/common";
+import Chance from "chance";
+const chance = new Chance();
+const sample = Object.assign(chance, {
+  dayjs: (opt) => dayjs(chance.date({ ...opt, min: opt?.min?.toDate(), max: opt?.max?.toDate() })),
+  pick: randomPick,
+  picks: randomPicks
+});
+export {
+  sample
+};

package/src/sampleOf.mjs

@@ -0,0 +1,57 @@
+import { Float, ID, Int, isGqlScalar, JSON, Upload } from "@akanjs/base";
+import { randomPick } from "@akanjs/common";
+import { getFieldMetas } from "@akanjs/constant";
+import { sample } from "./sample";
+const getFieldTypeExample = {
+  email: () => sample.email(),
+  password: () => sample.string({ length: 8 }),
+  url: () => sample.url()
+};
+const scalarSampleMap = /* @__PURE__ */ new Map([
+  [ID, () => sample.hash({ length: 24 })],
+  [Int, () => sample.integer({ min: -1e4, max: 1e4 })],
+  [Float, () => sample.floating({ min: -1e4, max: 1e4 })],
+  [String, () => sample.string({ length: 100 })],
+  [Boolean, () => sample.bool()],
+  [Date, () => sample.dayjs()],
+  [Upload, () => "FileUpload"],
+  [JSON, () => ({})]
+]);
+const getScalarSample = (ref, fieldMeta) => {
+  if (fieldMeta.type) {
+    return getFieldTypeExample[fieldMeta.type]();
+  } else if (typeof fieldMeta.min === "number") {
+    return fieldMeta.min;
+  } else if (typeof fieldMeta.max === "number") {
+    return fieldMeta.max;
+  } else {
+    return scalarSampleMap.get(ref)?.() ?? null;
+  }
+};
+const makeSample = (fieldMeta) => {
+  if (fieldMeta.default)
+    return typeof fieldMeta.default === "function" ? fieldMeta.default() : fieldMeta.default;
+  else if (fieldMeta.enum)
+    return randomPick([...fieldMeta.enum.values]);
+  if (isGqlScalar(fieldMeta.modelRef))
+    return getScalarSample(fieldMeta.modelRef, fieldMeta);
+  return Object.fromEntries(
+    getFieldMetas(fieldMeta.modelRef).map(
+      (fieldMeta2) => [
+        fieldMeta2.key,
+        fieldMeta2.arrDepth ? [] : fieldMeta2.isClass && !fieldMeta2.isScalar ? null : makeSample(fieldMeta2)
+      ]
+    )
+  );
+};
+const sampleOf = (modelRef) => {
+  return Object.fromEntries(
+    getFieldMetas(modelRef).map((fieldMeta) => [
+      fieldMeta.key,
+      fieldMeta.arrDepth ? [] : fieldMeta.isClass && !fieldMeta.isScalar ? null : makeSample(fieldMeta)
+    ])
+  );
+};
+export {
+  sampleOf
+};