@tachybase/test 0.23.8

package/es/index.mjs

@@ -0,0 +1,223 @@
+import { describe } from "vitest";
+import ws from "ws";
+import { mockDatabase } from "@tachybase/database";
+import { mockDatabase as mockDatabase2 } from "@tachybase/database";
+import supertest from "supertest";
+import { default as default2 } from "supertest";
+import { Application, Gateway, AppSupervisor, PluginManager } from "@tachybase/server";
+import jwt from "jsonwebtoken";
+import qs from "qs";
+class MockServer extends Application {
+  async loadAndInstall(options = {}) {
+    await this.load({ method: "install" });
+    if (options.afterLoad) {
+      await options.afterLoad(this);
+    }
+    await this.install({
+      ...options,
+      sync: {
+        force: false,
+        alter: {
+          drop: false
+        }
+      }
+    });
+  }
+  async cleanDb() {
+    await this.db.clean({ drop: true });
+  }
+  async quickstart(options = {}) {
+    const { clean } = options;
+    if (clean) {
+      await this.cleanDb();
+    }
+    await this.runCommand("start", "--quickstart");
+  }
+  async destroy(options = {}) {
+    await super.destroy(options);
+    Gateway.getInstance().destroy();
+    await AppSupervisor.getInstance().destroy();
+  }
+  agent() {
+    const agent = supertest.agent(this.callback());
+    const prefix = this.resourcer.options.prefix;
+    const proxy = new Proxy(agent, {
+      get(target, method, receiver) {
+        if (["login", "loginUsingId"].includes(method)) {
+          return (userOrId) => {
+            return proxy.auth(
+              jwt.sign(
+                {
+                  userId: typeof userOrId === "number" ? userOrId : userOrId == null ? void 0 : userOrId.id
+                },
+                process.env.APP_KEY,
+                {
+                  expiresIn: "1d"
+                }
+              ),
+              { type: "bearer" }
+            ).set("X-Authenticator", "basic");
+          };
+        }
+        if (method === "resource") {
+          return (name, resourceOf) => {
+            const keys = name.split(".");
+            const proxy2 = new Proxy(
+              {},
+              {
+                get(target2, method2, receiver2) {
+                  return (params = {}) => {
+                    let { filterByTk } = params;
+                    const { values = {}, file, ...restParams } = params;
+                    if (params.associatedIndex) {
+                      resourceOf = params.associatedIndex;
+                    }
+                    if (params.resourceIndex) {
+                      filterByTk = params.resourceIndex;
+                    }
+                    let url = prefix || "";
+                    if (keys.length > 1) {
+                      url += `/${keys[0]}/${resourceOf}/${keys[1]}`;
+                    } else {
+                      url += `/${name}`;
+                    }
+                    url += `:${method2}`;
+                    if (filterByTk) {
+                      url += `/${filterByTk}`;
+                    }
+                    const queryString = qs.stringify(restParams, { arrayFormat: "brackets" });
+                    let request;
+                    switch (method2) {
+                      case "list":
+                      case "get":
+                        request = agent.get(`${url}?${queryString}`);
+                        break;
+                      default:
+                        request = agent.post(`${url}?${queryString}`);
+                        break;
+                    }
+                    return file ? request.attach("file", file).field(values) : request.send(values);
+                  };
+                }
+              }
+            );
+            return proxy2;
+          };
+        }
+        return agent[method];
+      }
+    });
+    return proxy;
+  }
+  createDatabase(options) {
+    const oldDatabase = this.db;
+    const databaseOptions = oldDatabase ? oldDatabase.options : (options == null ? void 0 : options.database) || {};
+    const database = mockDatabase(databaseOptions);
+    database.setContext({ app: this });
+    return database;
+  }
+}
+function mockServer(options = {}) {
+  if (typeof TextEncoder === "undefined") {
+    global.TextEncoder = require("util").TextEncoder;
+  }
+  if (typeof TextDecoder === "undefined") {
+    global.TextDecoder = require("util").TextDecoder;
+  }
+  Gateway.getInstance().reset();
+  if (!PluginManager.findPackagePatched) {
+    PluginManager.getPackageJson = async () => {
+      return {
+        version: "0.0.0"
+      };
+    };
+    PluginManager.findPackagePatched = true;
+  }
+  const app = new MockServer({
+    acl: false,
+    ...options
+  });
+  return app;
+}
+async function startMockServer(options = {}) {
+  const app = mockServer(options);
+  await app.runCommand("start");
+  return app;
+}
+async function createMockServer(options = {}) {
+  const { version, beforeInstall, skipInstall, skipStart, ...others } = options;
+  const app = mockServer(others);
+  if (!skipInstall) {
+    if (beforeInstall) {
+      await beforeInstall(app);
+    }
+    await app.runCommandThrowError("install", "-f");
+  }
+  if (version) {
+    await app.version.update(version);
+  }
+  if (!skipStart) {
+    await app.runCommandThrowError("start");
+  }
+  return app;
+}
+const pgOnly = () => process.env.DB_DIALECT == "postgres" ? describe : describe.skip;
+const isPg = () => process.env.DB_DIALECT == "postgres";
+function randomStr() {
+  return Math.random().toString(36).substring(2);
+}
+const waitSecond = async (timeout = 1e3) => {
+  await new Promise((resolve) => setTimeout(resolve, timeout));
+};
+const startServerWithRandomPort = async (startServer) => {
+  return await new Promise((resolve) => {
+    startServer({
+      port: 0,
+      host: "localhost",
+      callback(server) {
+        const port = server.address().port;
+        resolve(port);
+      }
+    });
+  });
+};
+const createWsClient = async ({ serverPort, options = {} }) => {
+  console.log(`connect to ws://localhost:${serverPort}${process.env.WS_PATH}`, options);
+  const wsc = new ws(`ws://localhost:${serverPort}${process.env.WS_PATH}`, options);
+  const messages = [];
+  wsc.on("message", (data) => {
+    const message = data.toString();
+    messages.push(message);
+  });
+  await new Promise((resolve) => {
+    wsc.on("open", resolve);
+  });
+  return {
+    wsc,
+    messages,
+    async stop() {
+      const promise = new Promise((resolve) => {
+        wsc.on("close", resolve);
+      });
+      wsc.close();
+      await promise;
+    },
+    lastMessage() {
+      return JSON.parse(messages[messages.length - 1]);
+    }
+  };
+};
+export {
+  MockServer,
+  createMockServer,
+  createWsClient,
+  isPg,
+  mockDatabase2 as mockDatabase,
+  mockServer,
+  pgOnly,
+  randomStr,
+  startMockServer,
+  startServerWithRandomPort,
+  default2 as supertest,
+  waitSecond
+};

package/es/scripts/test-db-creator.d.ts

@@ -0,0 +1 @@
+export {};

package/es/scripts/test-db-distributor.d.ts

@@ -0,0 +1 @@
+export {};

package/es/server/index.d.ts

@@ -0,0 +1,17 @@
+export { mockDatabase } from '@tachybase/database';
+export { default as supertest } from 'supertest';
+export * from './mockServer';
+export declare const pgOnly: () => any;
+export declare const isPg: () => boolean;
+export declare function randomStr(): string;
+export declare const waitSecond: (timeout?: number) => Promise<void>;
+export declare const startServerWithRandomPort: (startServer: any) => Promise<unknown>;
+export declare const createWsClient: ({ serverPort, options }: {
+    serverPort: any;
+    options?: {};
+}) => Promise<{
+    wsc: any;
+    messages: any[];
+    stop(): Promise<void>;
+    lastMessage(): any;
+}>;

package/es/server/mockServer.d.ts

@@ -0,0 +1,75 @@
+import { Application, ApplicationOptions } from '@tachybase/server';
+import supertest, { SuperAgentTest } from 'supertest';
+interface ActionParams {
+    filterByTk?: any;
+    fields?: string[];
+    filter?: any;
+    sort?: string[];
+    page?: number;
+    pageSize?: number;
+    values?: any;
+    /**
+     * @deprecated
+     */
+    resourceName?: string;
+    /**
+     * @deprecated
+     */
+    resourceIndex?: string;
+    /**
+     * @deprecated
+     */
+    associatedName?: string;
+    /**
+     * @deprecated
+     */
+    associatedIndex?: string;
+    [key: string]: any;
+}
+interface SortActionParams {
+    resourceName?: string;
+    resourceIndex?: any;
+    associatedName?: string;
+    associatedIndex?: any;
+    sourceId?: any;
+    targetId?: any;
+    sortField?: string;
+    method?: string;
+    target?: any;
+    sticky?: boolean;
+    [key: string]: any;
+}
+interface Resource {
+    get: (params?: ActionParams) => Promise<supertest.Response>;
+    list: (params?: ActionParams) => Promise<supertest.Response>;
+    create: (params?: ActionParams) => Promise<supertest.Response>;
+    update: (params?: ActionParams) => Promise<supertest.Response>;
+    destroy: (params?: ActionParams) => Promise<supertest.Response>;
+    sort: (params?: SortActionParams) => Promise<supertest.Response>;
+    [name: string]: (params?: ActionParams) => Promise<supertest.Response>;
+}
+interface ExtendedAgent extends SuperAgentTest {
+    login: (user: any) => ExtendedAgent;
+    loginUsingId: (userId: number) => ExtendedAgent;
+    resource: (name: string, resourceOf?: any) => Resource;
+}
+export declare class MockServer extends Application {
+    loadAndInstall(options?: any): Promise<void>;
+    cleanDb(): Promise<void>;
+    quickstart(options?: {
+        clean?: boolean;
+    }): Promise<void>;
+    destroy(options?: any): Promise<void>;
+    agent(): ExtendedAgent;
+    protected createDatabase(options: ApplicationOptions): import("@tachybase/database").MockDatabase;
+}
+export declare function mockServer(options?: ApplicationOptions): MockServer;
+export declare function startMockServer(options?: ApplicationOptions): Promise<MockServer>;
+type BeforeInstallFn = (app: any) => Promise<void>;
+export declare function createMockServer(options?: ApplicationOptions & {
+    version?: string;
+    beforeInstall?: BeforeInstallFn;
+    skipInstall?: boolean;
+    skipStart?: boolean;
+}): Promise<any>;
+export default mockServer;

package/lib/client/index.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+export type { queries } from '@testing-library/dom';
+declare function customRender(ui: React.ReactElement, options?: {}): import("@testing-library/react").RenderResult<typeof import("@testing-library/dom/types/queries"), HTMLElement, HTMLElement>;
+export * from '@testing-library/react';
+export { default as userEvent } from '@testing-library/user-event';
+export { customRender as render };
+export declare const sleep: (timeout?: number) => Promise<unknown>;

package/lib/client/index.js

@@ -0,0 +1,59 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var client_exports = {};
+__export(client_exports, {
+  render: () => customRender,
+  sleep: () => sleep,
+  userEvent: () => import_user_event.default
+});
+module.exports = __toCommonJS(client_exports);
+var import_react2 = require("@testing-library/react");
+__reExport(client_exports, require("@testing-library/react"), module.exports);
+var import_user_event = __toESM(require("@testing-library/user-event"));
+function customRender(ui, options = {}) {
+  return (0, import_react2.render)(ui, {
+    // wrap provider(s) here if needed
+    wrapper: /* @__PURE__ */ __name(({ children }) => children, "wrapper"),
+    ...options
+  });
+}
+__name(customRender, "customRender");
+const sleep = /* @__PURE__ */ __name(async (timeout = 0) => {
+  return new Promise((resolve) => {
+    setTimeout(resolve, timeout);
+  });
+}, "sleep");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  render,
+  sleep,
+  userEvent,
+  ...require("@testing-library/react")
+});

package/lib/e2e/defineConfig.d.ts

@@ -0,0 +1,2 @@
+import { type PlaywrightTestConfig } from '@playwright/test';
+export declare const defineConfig: (config?: PlaywrightTestConfig) => PlaywrightTestConfig<{}, {}>;

package/lib/e2e/defineConfig.js

@@ -0,0 +1,78 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var defineConfig_exports = {};
+__export(defineConfig_exports, {
+  defineConfig: () => defineConfig
+});
+module.exports = __toCommonJS(defineConfig_exports);
+var import_test = require("@playwright/test");
+const defineConfig = /* @__PURE__ */ __name((config) => {
+  return (0, import_test.defineConfig)({
+    timeout: 5 * 60 * 1e3,
+    expect: {
+      timeout: 10 * 1e3
+    },
+    // Look for test files in the "tests" directory, relative to this configuration file.
+    testDir: "packages",
+    // Match all test files in the e2e and __e2e__ directories.
+    testMatch: /(.*\/e2e\/|.*\/__e2e__\/).+\.test\.[tj]sx*$/,
+    // Run all tests in parallel.
+    fullyParallel: false,
+    // Fail the build on CI if you accidentally left test.only in the source code.
+    forbidOnly: !!process.env.CI,
+    retries: 2,
+    // Opt out of parallel tests on CI.
+    // workers: process.env.CI ? 1 : undefined,
+    workers: 1,
+    maxFailures: 0,
+    // Reporter to use
+    reporter: process.env.PLAYWRIGHT_SKIP_REPORTER ? void 0 : [["html", { outputFolder: "./storage/playwright/tests-report" }]],
+    outputDir: "./storage/playwright/test-results",
+    use: {
+      // Base URL to use in actions like `await page.goto('/')`.
+      baseURL: process.env.APP_BASE_URL || `http://localhost:${process.env.APP_PORT || 2e4}`,
+      // Collect trace when retrying the failed test.
+      trace: "on-first-retry"
+    },
+    // Configure projects for major browsers.
+    projects: [
+      {
+        name: "authSetup",
+        testDir: "./storage/playwright/tests",
+        testMatch: "auth.setup.ts"
+      },
+      {
+        name: "chromium",
+        use: {
+          ...import_test.devices["Desktop Chrome"],
+          storageState: process.env.PLAYWRIGHT_AUTH_FILE,
+          contextOptions: {
+            // chromium-specific permissions
+            permissions: ["clipboard-read", "clipboard-write"]
+          }
+        },
+        dependencies: ["authSetup"]
+      }
+    ]
+  });
+}, "defineConfig");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defineConfig
+});