@team-codeme/crud-forge 0.0.0-stage → 1.0.1

package/src/generator/application-tests.js

@@ -0,0 +1,252 @@
+const fs = require("fs-extra"),
+  path = require("path"),
+  _ = require("lodash");
+function defaultFixtureValue(field, enums, override) {
+  if (override !== undefined) {
+    if (
+      field.fieldValidateRules?.includes("required") &&
+      (override === null || override === "")
+    )
+      throw Error(
+        `testing.fixtures.${field.fieldName} must provide a required value.`,
+      );
+    for (const rule of field.fieldValidateRules || []) {
+      if (
+        rule.startsWith("pattern(") &&
+        !require("../validator/pattern").matchesPattern(
+          rule.slice(8, -1),
+          override,
+        )
+      )
+        throw Error(
+          `testing.fixtures.${field.fieldName} does not match its pattern.`,
+        );
+    }
+    return override;
+  }
+  if (field.fieldTypeIsEnum)
+    return enums.find((e) => e.name === field.fieldType)?.values[0]?.name;
+  const rules = field.fieldValidateRules || [];
+  const number = (key, fallback) => {
+    const r = rules.find((r) => r.startsWith(key + "("));
+    return r ? Number(r.slice(key.length + 1, -1)) : fallback;
+  };
+  if (field.fieldType === "Boolean") return true;
+  if (
+    ["Integer", "Long", "Float", "Double", "BigDecimal"].includes(
+      field.fieldType,
+    )
+  )
+    return Math.min(number("max", 100), Math.max(number("min", 1), 1));
+  if (["LocalDate", "Instant", "ZonedDateTime"].includes(field.fieldType))
+    return field.fieldType === "LocalDate"
+      ? "2026-01-15"
+      : "2026-01-15T00:00:00Z";
+  if (field.fieldType === "UUID") return "00000000-0000-4000-8000-000000000001";
+  if (rules.some((r) => r.startsWith("pattern(")))
+    throw Error(
+      `Set testing.fixtures for ${field.fieldName}: a valid pattern-matching value is required; the generator will not guess.`,
+    );
+  return "Example"
+    .padEnd(number("minlength", 1), "a")
+    .slice(0, number("maxlength", 100));
+}
+function fixtureValue(field, enums, override) {
+  const value = defaultFixtureValue(field, enums, override);
+  const fail = (reason) => {
+    throw new Error(
+      `Invalid testing.fixtures value for ${field.fieldName}: ${reason}`,
+    );
+  };
+  if (
+    field.fieldTypeIsEnum &&
+    !enums
+      .find((e) => e.name === field.fieldType)
+      ?.values.some((v) => v.name === value)
+  )
+    fail("choose a declared enum value.");
+  if (field.fieldType === "Boolean" && typeof value !== "boolean")
+    fail("expected a boolean.");
+  if (
+    ["Integer", "Long", "Float", "Double", "BigDecimal"].includes(
+      field.fieldType,
+    ) &&
+    !Number.isFinite(value)
+  )
+    fail("expected a finite number.");
+  if (["Integer", "Long"].includes(field.fieldType) && !Number.isInteger(value))
+    fail("expected an integer.");
+  if (
+    ["LocalDate", "Instant", "ZonedDateTime"].includes(field.fieldType) &&
+    !Number.isFinite(Date.parse(value))
+  )
+    fail("expected a valid ISO date.");
+  if (
+    ["String", "TextBlob", "UUID"].includes(field.fieldType) &&
+    typeof value !== "string"
+  )
+    fail("expected a string.");
+  for (const rule of field.fieldValidateRules || []) {
+    const m = /^(min|max|minlength|maxlength)\(([^)]+)\)$/.exec(rule);
+    if (m) {
+      const n = m[1].endsWith("length") ? String(value).length : value;
+      if (
+        (m[1].startsWith("min") && n < Number(m[2])) ||
+        (m[1].startsWith("max") && n > Number(m[2]))
+      )
+        fail(`does not satisfy ${rule}.`);
+    }
+    if (rule === "required" && (value == null || value === ""))
+      fail("a non-empty value is required.");
+  }
+  return value;
+}
+async function applyApplicationTests({
+  outputDir,
+  config,
+  parsedData,
+  writeOrPreview,
+}) {
+  if (!config.generate?.globals?.tests) return;
+  if (!config.fuse?.enabled)
+    throw Error(
+      "generate.globals.tests currently requires fuse.enabled; component-only output has no standalone application to start.",
+    );
+  const write = (name, body) =>
+    writeOrPreview(
+      path.join(outputDir, name),
+      typeof body === "string" ? body : JSON.stringify(body, null, 2) + "\n",
+    );
+  const schema = parsedData.entities.map((entity) => ({
+    name: entity.name,
+    slug: _.kebabCase(entity.name),
+    url: `${config.api.microservice ? "/services/" + config.api.microservice : ""}${(config.api.baseUrl || "/api").replace(/\/$/, "")}/${_.kebabCase(entity.name)}s`,
+    fields: entity.fields
+      .filter((f) => !(config.fields?.audit?.names || []).includes(f.fieldName))
+      .map((f) => ({
+        ...f,
+        value: fixtureValue(
+          f,
+          parsedData.enums,
+          config.testing?.fixtures?.[entity.name]?.[f.fieldName],
+        ),
+      })),
+    relationships: parsedData.relationships
+      .filter((r) => r.from.name === entity.name)
+      .map((r) => ({
+        field: r.from.fieldName || _.camelCase(r.to.name),
+        target: r.to.name,
+        many: ["OneToMany", "ManyToMany"].includes(r.type),
+      })),
+  }));
+  write("tests/generated/schema.json", {
+    entities: schema,
+    auth: config.auth?.provider === "keycloak",
+    formMode: config.ui?.formMode,
+  });
+  for (const name of [
+    "mock.cjs",
+    "smoke.spec.cjs",
+    "serve.cjs",
+    "playwright.config.cjs",
+    "ci.cjs",
+  ])
+    write(
+      "tests/generated/" + name,
+      await fs.readFile(
+        path.join(__dirname, "../templates/testing", name),
+        "utf8",
+      ),
+    );
+  // This file lives only in the test build; the normal production environment is unchanged.
+  let env = await fs.readFile(
+    path.join(outputDir, "src/environments/environment.ts"),
+    "utf8",
+  );
+  env = env
+    .replace(/https?:\/\/[^'"\s]+/g, "http://127.0.0.1:4297/test-only")
+    .replace(/useMockAuth:\s*true/g, "useMockAuth: false");
+  write("src/environments/environment.smoke.ts", env);
+  write("tests/generated/proxy.json", {});
+  const angular = await fs.readJson(path.join(outputDir, "angular.json"));
+  const targets = angular.projects.fuse.architect;
+  const replacements = [
+    {
+      replace: "src/environments/environment.ts",
+      with: "src/environments/environment.smoke.ts",
+    },
+  ];
+  // Exercise HTTP even when developers normally opt into generated in-memory mocks.
+  async function visit(dir) {
+    for (const entry of await fs.readdir(dir, { withFileTypes: true })) {
+      const file = path.join(dir, entry.name);
+      if (entry.isDirectory()) await visit(file);
+      else if (entry.name === "settings.config.ts") {
+        const relative = path
+          .relative(outputDir, file)
+          .split(path.sep)
+          .join("/");
+        const replacement = relative.replace(".ts", ".smoke.ts");
+        write(
+          replacement,
+          (await fs.readFile(file, "utf8")).replace(
+            /useMockData:\s*true/g,
+            "useMockData: false",
+          ),
+        );
+        replacements.push({ replace: relative, with: replacement });
+      }
+    }
+  }
+  await visit(path.join(outputDir, "src/app/domains/admin/modules/apps"));
+  targets.build.configurations["crudforge-test"] = {
+    tsConfig: "tsconfig.smoke.json",
+    optimization: false,
+    sourceMap: true,
+    extractLicenses: false,
+    server: false,
+    ssr: false,
+    prerender: false,
+    outputMode: "static",
+    fileReplacements: replacements,
+  };
+  targets.serve.configurations["crudforge-test"] = {
+    buildTarget: "fuse:build:crudforge-test",
+    proxyConfig: "tests/generated/proxy.json",
+    port: 4297,
+  };
+  write("angular.json", angular);
+  write("tsconfig.smoke.json", {
+    extends: "./tsconfig.app.json",
+    files: ["src/main.ts"],
+    include: ["src/**/*.d.ts"],
+    compilerOptions: { types: [] },
+  });
+  const pkg = await fs.readJson(path.join(outputDir, "package.json"));
+  const lock = await fs.readJson(path.join(outputDir, "package-lock.json"));
+  const toolLock = require("../../package-lock.json");
+  const version = toolLock.packages["node_modules/@playwright/test"].version;
+  pkg.devDependencies["@playwright/test"] = version;
+  pkg.scripts["test:smoke"] =
+    "playwright test --config tests/generated/playwright.config.cjs";
+  pkg.scripts["test:smoke:install"] = "playwright install chromium";
+  lock.packages[""].devDependencies = pkg.devDependencies;
+  for (const name of ["@playwright/test", "playwright", "playwright-core"])
+    lock.packages["node_modules/" + name] =
+      toolLock.packages["node_modules/" + name];
+  if (toolLock.packages["node_modules/playwright/node_modules/fsevents"])
+    lock.packages["node_modules/playwright/node_modules/fsevents"] =
+      toolLock.packages["node_modules/playwright/node_modules/fsevents"];
+  write("package.json", pkg);
+  write("package-lock.json", lock);
+  write(
+    "tests/README.md",
+    `# Application smoke tests\n\nRun npm ci, npm run test:smoke:install, then npm run test:smoke. Node must satisfy package.json engines.\n\nGenerated tests live in tests/generated. Put developer-owned tests in tests/custom/*.spec.cjs; generation never emits files there. Example:\n\n\`\`\`js\nconst {test, expect} = require('../generated/mock.cjs');\ntest('my screen', async ({page, backend}) => {\n  await backend.login(page);\n  await page.goto('/admin');\n  await expect(page.locator('body')).toBeVisible();\n});\n\`\`\`\n\nReplace the assertion with your screen's heading or observable workflow. Use the backend fixture to keep network isolation. Unknown fetches are aborted; only the isolated loopback server serves application assets. Tests never use a running production server. Service workers are blocked. The test build disables SSR and proxy forwarding.\n\nThese tests verify frontend behavior with synthetic data and identity, not live backend authorization, persistence, or API compatibility. No live credentials belong in fixtures. Pattern-constrained fields require explicit testing.fixtures.Entity.field values. Backend-specific integration tests remain developer-owned.\n\nRegeneration applies normal conflict policies to generated tests and CI files. HTML reports and failure screenshots contain synthetic test data; tracing/video are disabled. Do not insert secrets in custom test data or enable live endpoints in this suite.\n`,
+  );
+  if (config.testing?.ci)
+    write(
+      ".github/workflows/crudforge-smoke.yml",
+      `name: CRUDForge smoke\non: [push, pull_request]\npermissions:\n  contents: read\njobs:\n  smoke:\n    runs-on: ubuntu-latest\n    timeout-minutes: 20\n    steps:\n      - uses: actions/checkout@v4\n      - uses: actions/setup-node@v4\n        with:\n          node-version-file: package.json\n      - name: Enable pinned package managers\n        run: npm install --global corepack\n      - run: node tests/generated/ci.cjs install\n      - run: node tests/generated/ci.cjs build\n      - run: node tests/generated/ci.cjs browsers\n      - run: node tests/generated/ci.cjs test\n      - uses: actions/upload-artifact@v4\n        if: failure()\n        with:\n          name: smoke-report\n          path: |\n            playwright-report/\n            test-results/\n          retention-days: 7\n`,
+    );
+}
+module.exports = { applyApplicationTests, fixtureValue };