@alejandrojca/elmulo-reporter 2.0.0-beta.5

package/assets/fonts/OFL.txt

@@ -0,0 +1,93 @@
+Copyright 2022 The Noto Project Authors (https://github.com/notofonts/latin-greek-cyrillic)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+https://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

package/cli.cjs

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { createRunId, ensureDir, stableId, writeJson } = require("./core.cjs");
+const { finalizeRun } = require("./finalize.cjs");
+const { serveReport } = require("./server.cjs");
+
+function createDemoRun(projectRoot) {
+  const outputDir = path.resolve(
+    projectRoot,
+    process.env.ELMULO_OUTPUT_DIR || "elmulo-results",
+  );
+  const startedAt = new Date(Date.now() - 84_000).toISOString();
+  const endedAt = new Date().toISOString();
+  const runId = createRunId(startedAt);
+  const runDir = path.join(outputDir, "runs", runId);
+  ensureDir(runDir);
+
+  const definitions = [
+    {
+      spec: "cypress/e2e/decidir/mtt/mtt-payment.feature",
+      title: "MTT payment with brand TARJETA NARANJA and DUKPT",
+      status: "passed",
+      durationMs: 22430,
+      retries: 0,
+      flaky: false,
+    },
+    {
+      spec: "cypress/e2e/decidir/mtt/mtt-payment.feature",
+      title: "MTT payment with brand CABAL DEBIT and DUKPT",
+      status: "passed",
+      durationMs: 28190,
+      retries: 1,
+      flaky: true,
+    },
+    {
+      spec: "cypress/e2e/decidir/mtt/mtt-payment.feature",
+      title: "MTT payment with brand CABAL CREDIT and DUKPT",
+      status: "failed",
+      durationMs: 33380,
+      retries: 1,
+      flaky: false,
+    },
+    {
+      spec: "cypress/e2e/decidir/mtt/mtt-payment-negative.feature",
+      title: "Reject MTT payment with an invalid cryptogram",
+      status: "skipped",
+      durationMs: 0,
+      retries: 0,
+      flaky: false,
+    },
+  ];
+
+  const tests = definitions.map((definition, index) => ({
+    id: stableId(definition.spec, definition.title),
+    ...definition,
+    titlePath: ["MTT payment from API", definition.title],
+    suite: "MTT payment from API",
+    error:
+      definition.status === "failed"
+        ? {
+            name: "AssertionError",
+            message: "expected response status 201 but received 500",
+            stack:
+              "AssertionError: expected response status 201 but received 500\n    at Context.eval (mtt-payment.feature:25:5)",
+          }
+        : null,
+    attempts: Array.from(
+      { length: definition.retries + 1 },
+      (_, attemptIndex) => ({
+        index: attemptIndex,
+        number: attemptIndex + 1,
+        state:
+          attemptIndex < definition.retries
+            ? "failed"
+            : definition.status,
+        durationMs: Math.round(
+          definition.durationMs / (definition.retries + 1),
+        ),
+        startedAt,
+        error:
+          attemptIndex < definition.retries ||
+          definition.status === "failed"
+            ? {
+                name: "AssertionError",
+                message: "La respuesta no coincidió con el contrato esperado",
+                stack: "AssertionError: respuesta inesperada",
+              }
+            : null,
+        screenshots: [],
+        video: null,
+      }),
+    ),
+    steps: [
+      {
+        index: 0,
+        keyword: "Given",
+        name: "A random amount is generated for the MTT payment",
+        status: "passed",
+        durationMs: 120,
+        error: "",
+      },
+      {
+        index: 1,
+        keyword: "When",
+        name: "The MTT payment request is sent",
+        status: definition.status === "failed" ? "failed" : "passed",
+        durationMs: Math.max(0, definition.durationMs - 120),
+        error:
+          definition.status === "failed"
+            ? "El servicio respondió HTTP 500"
+            : "",
+      },
+      {
+        index: 2,
+        keyword: "Then",
+        name: "The MTT payment response is successful",
+        status:
+          definition.status === "failed"
+            ? "skipped"
+            : definition.status,
+        durationMs: 0,
+        error: "",
+      },
+    ],
+    tags: ["@mtt", "@smoke"],
+    logs: [
+      {
+        name: "request",
+        message: "POST /api/v1/payments",
+        timestamp: startedAt,
+      },
+      {
+        name: "assert",
+        message: `status: ${definition.status}`,
+        timestamp: endedAt,
+      },
+    ],
+    attachments: [],
+  }));
+
+  const counts = tests.reduce(
+    (summary, test) => {
+      summary.total += 1;
+      summary[test.status] += 1;
+      if (test.flaky) summary.flaky += 1;
+      return summary;
+    },
+    {
+      total: 0,
+      passed: 0,
+      failed: 0,
+      pending: 0,
+      skipped: 0,
+      unknown: 0,
+      flaky: 0,
+    },
+  );
+
+  const run = {
+    schemaVersion: 3,
+    id: runId,
+    projectName: "acceptance-tests",
+    environment: "sandbox",
+    tagExpression: "@mtt and not @negative",
+    status: "failed",
+    startedAt,
+    endedAt,
+    durationMs: 84000,
+    browser: { name: "chrome", version: "150" },
+    cypressVersion: "14.5.4",
+    system: { name: "win32", version: "11" },
+    counts,
+    specs: [
+      {
+        path: "cypress/e2e/decidir/mtt/mtt-payment.feature",
+        name: "mtt-payment.feature",
+        durationMs: 84000,
+        video: null,
+        testIds: tests.map((test) => test.id),
+      },
+    ],
+    tests,
+    attachments: [],
+    trends: [],
+    generatedAt: endedAt,
+    lifecycle: "completed",
+    source: {
+      branch: "feature/elmulo-v2",
+      commit: "demo",
+      pipelineId: "local-demo",
+      jobId: "",
+      jobUrl: "",
+    },
+    execution: {
+      runner: "npm",
+      script: "demo",
+    },
+  };
+
+  writeJson(path.join(runDir, "run.raw.json"), run);
+  writeJson(path.join(runDir, "run.json"), run);
+  fs.writeFileSync(path.join(outputDir, "latest-run.txt"), runId, "utf8");
+  return run;
+}
+
+function applyRetention(projectRoot, keepValue) {
+  const outputDir = path.resolve(
+    projectRoot,
+    process.env.ELMULO_OUTPUT_DIR || "elmulo-results",
+  );
+  const runsDir = path.join(outputDir, "runs");
+  const keep = Math.max(1, Math.min(1000, Number(keepValue || 50)));
+  if (!fs.existsSync(runsDir)) return { keep, removed: 0 };
+  const runs = fs.readdirSync(runsDir, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && /^[a-zA-Z0-9_-]+$/.test(entry.name))
+    .map((entry) => ({
+      name: entry.name,
+      path: path.join(runsDir, entry.name),
+      modifiedAt: fs.statSync(path.join(runsDir, entry.name)).mtimeMs,
+    }))
+    .sort((left, right) => right.modifiedAt - left.modifiedAt);
+  const removable = runs.slice(keep);
+  for (const run of removable) {
+    const resolved = path.resolve(run.path);
+    if (!resolved.startsWith(`${path.resolve(runsDir)}${path.sep}`)) {
+      throw new Error("La retención intentó salir del directorio de corridas.");
+    }
+    fs.rmSync(resolved, { recursive: true, force: false });
+  }
+  return { keep, removed: removable.length };
+}
+
+async function main() {
+  const projectRoot = process.cwd();
+  const command = process.argv[2] || "finalize";
+
+  if (command === "serve") {
+    const result = await serveReport({
+      projectRoot,
+      outputDir: process.env.ELMULO_OUTPUT_DIR,
+      port: process.argv[3],
+    });
+    console.log(`[elmulo] Reporte disponible en ${result.url}`);
+    console.log("[elmulo] Las clasificaciones se persisten en SQLite.");
+    return;
+  }
+
+  if (command === "retention") {
+    const result = applyRetention(projectRoot, process.argv[3]);
+    console.log(`[elmulo-v2] Retención aplicada: ${result.keep} corridas conservadas, ${result.removed} eliminadas.`);
+    return;
+  }
+
+  if (command === "demo") createDemoRun(projectRoot);
+  if (!["demo", "finalize", "serve", "retention"].includes(command)) {
+    throw new Error(`Comando desconocido: ${command}`);
+  }
+
+  const result = await finalizeRun({
+    projectRoot,
+    outputDir: process.env.ELMULO_OUTPUT_DIR,
+  });
+  console.log(`[elmulo] Reporte generado: ${path.join(result.reportDir, "index.html")}`);
+  console.log(`[elmulo] Historial SQLite: ${path.join(result.outputDir, "elmulo.sqlite")}`);
+}
+
+main().catch((error) => {
+  console.error(`[elmulo] ${error.stack || error.message}`);
+  process.exitCode = 1;
+});

package/core.cjs

@@ -0,0 +1,274 @@
+const crypto = require("node:crypto");
+const fs = require("node:fs");
+const path = require("node:path");
+
+const SCHEMA_VERSION = 3;
+
+function ensureDir(directory) {
+  fs.mkdirSync(directory, { recursive: true });
+}
+
+function safeFileName(value) {
+  return String(value || "artifact")
+    .normalize("NFKD")
+    .replace(/[^\w.-]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 120) || "artifact";
+}
+
+function stableId(...parts) {
+  return crypto
+    .createHash("sha1")
+    .update(parts.filter(Boolean).join("\u001f"))
+    .digest("hex");
+}
+
+function atomicWriteFile(filePath, content) {
+  ensureDir(path.dirname(filePath));
+  const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  fs.writeFileSync(temporaryPath, content);
+  fs.renameSync(temporaryPath, filePath);
+}
+
+function createRunId(startedAt = new Date().toISOString()) {
+  const compactDate = startedAt.replace(/\D/g, "").slice(0, 14);
+  return `${compactDate}-${crypto.randomBytes(4).toString("hex")}`;
+}
+
+function normalizeStatus(status) {
+  const value = String(status || "").toLowerCase();
+
+  if (value === "passed") return "passed";
+  if (value === "failed") return "failed";
+  if (value === "pending") return "pending";
+  if (value === "skipped") return "skipped";
+  return value || "unknown";
+}
+
+function normalizePath(projectRoot, candidate) {
+  if (!candidate) return null;
+  const absolutePath = path.isAbsolute(candidate)
+    ? candidate
+    : path.resolve(projectRoot, candidate);
+
+  return {
+    absolutePath,
+    projectPath: path.relative(projectRoot, absolutePath).replaceAll("\\", "/"),
+  };
+}
+
+function comparableText(value) {
+  return String(value || "")
+    .normalize("NFKD")
+    .replace(/[\u0300-\u036f]/g, "")
+    .replace(/[^a-zA-Z0-9]+/g, " ")
+    .trim()
+    .toLowerCase();
+}
+
+function normalizeAttempt(projectRoot, attempt, index, specVideo) {
+  const screenshots = (attempt?.screenshots || [])
+    .map((screenshot) => normalizePath(projectRoot, screenshot.path))
+    .filter(Boolean)
+    .map((screenshot) => ({
+      ...screenshot,
+      takenAt: null,
+      width: null,
+      height: null,
+    }));
+
+  return {
+    index,
+    number: index + 1,
+    state: normalizeStatus(attempt?.state),
+    durationMs: Number(attempt?.duration || 0),
+    startedAt: attempt?.startedAt || null,
+    error: attempt?.error
+      ? {
+          name: attempt.error.name || "Error",
+          message: attempt.error.message || "",
+          stack: attempt.error.stack || attempt.error.message || "",
+        }
+      : null,
+    screenshots,
+    video: normalizePath(projectRoot, specVideo),
+  };
+}
+
+function normalizeCypressResults(results, context) {
+  const projectRoot = context.projectRoot;
+  const startedAt =
+    results?.startedTestsAt || context.startedAt || new Date().toISOString();
+  const endedAt = results?.endedTestsAt || new Date().toISOString();
+  const runId = context.runId || createRunId(startedAt);
+  const tests = [];
+  const specs = [];
+
+  for (const specRun of results?.runs || []) {
+    const specPath =
+      specRun?.spec?.relative || specRun?.spec?.name || "unknown-spec";
+    const specVideo = specRun?.video || null;
+    const specTests = [];
+    const normalizedSpecTests = [];
+    const specScreenshots = (specRun?.screenshots || [])
+      .map((screenshot) => {
+        const normalized = normalizePath(projectRoot, screenshot.path);
+        return normalized
+          ? {
+              ...normalized,
+              name: screenshot.name || path.basename(screenshot.path),
+              takenAt: screenshot.takenAt || null,
+              width: screenshot.width || null,
+              height: screenshot.height || null,
+            }
+          : null;
+      })
+      .filter(Boolean);
+
+    for (const test of specRun?.tests || []) {
+      const titlePath = Array.isArray(test.title)
+        ? test.title
+        : Array.isArray(test.titlePath)
+          ? test.titlePath
+          : [test.title || "Unnamed test"];
+      const attempts = (test.attempts || []).map((attempt, index) =>
+        normalizeAttempt(projectRoot, attempt, index, specVideo),
+      );
+      const finalAttempt = attempts.at(-1);
+      const status = normalizeStatus(test.state || finalAttempt?.state);
+      const testId = stableId(
+        context.projectName || "acceptance-tests",
+        specPath,
+        ...titlePath,
+      );
+      const normalizedTest = {
+        id: testId,
+        identityVersion: 2,
+        spec: specPath.replaceAll("\\", "/"),
+        title: titlePath.at(-1),
+        titlePath,
+        suite: titlePath.slice(0, -1).join(" › "),
+        status,
+        durationMs: attempts.reduce(
+          (total, attempt) => total + attempt.durationMs,
+          0,
+        ),
+        retries: Math.max(0, attempts.length - 1),
+        flaky: status === "passed" && attempts.some((attempt) => attempt.state === "failed"),
+        error:
+          finalAttempt?.error ||
+          (test.displayError
+            ? {
+                name: "Error",
+                message: test.displayError,
+                stack: test.displayError,
+              }
+            : null),
+        attempts,
+        steps: [],
+        tags: [],
+        logs: [],
+        http: [],
+        attachments: [],
+      };
+
+      tests.push(normalizedTest);
+      normalizedSpecTests.push(normalizedTest);
+      specTests.push(testId);
+    }
+
+    const failedSpecTests = normalizedSpecTests.filter(
+      (test) => test.status === "failed",
+    );
+    for (const screenshot of specScreenshots) {
+      const screenshotText = comparableText(
+        `${screenshot.name} ${screenshot.projectPath}`,
+      );
+      const matchingTest =
+        normalizedSpecTests.find((test) =>
+          screenshotText.includes(comparableText(test.title)),
+        ) ||
+        (failedSpecTests.length === 1 ? failedSpecTests[0] : null);
+      const finalAttempt = matchingTest?.attempts?.at(-1);
+      if (finalAttempt) finalAttempt.screenshots.push(screenshot);
+    }
+
+    specs.push({
+      path: specPath.replaceAll("\\", "/"),
+      name: specRun?.spec?.name || path.basename(specPath),
+      durationMs: Number(specRun?.stats?.duration || 0),
+      video: normalizePath(projectRoot, specVideo),
+      screenshots: specScreenshots,
+      testIds: specTests,
+    });
+  }
+
+  const counts = tests.reduce(
+    (summary, test) => {
+      summary.total += 1;
+      summary[test.status] = (summary[test.status] || 0) + 1;
+      if (test.flaky) summary.flaky += 1;
+      return summary;
+    },
+    {
+      total: 0,
+      passed: 0,
+      failed: 0,
+      pending: 0,
+      skipped: 0,
+      unknown: 0,
+      flaky: 0,
+    },
+  );
+
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id: runId,
+    projectName: context.projectName || "acceptance-tests",
+    environment: context.environment || "unknown",
+    tagExpression: context.tagExpression || "",
+    status: counts.failed > 0 ? "failed" : "passed",
+    startedAt,
+    endedAt,
+    durationMs: Number(results?.totalDuration || 0),
+    browser: {
+      name: results?.browserName || "",
+      version: results?.browserVersion || "",
+    },
+    cypressVersion: results?.cypressVersion || "",
+    source: {
+      branch: context.branch || process.env.CI_COMMIT_REF_NAME || "",
+      commit: context.commit || process.env.CI_COMMIT_SHA || "",
+      pipelineId: context.pipelineId || process.env.CI_PIPELINE_ID || "",
+      jobId: context.jobId || process.env.CI_JOB_ID || "",
+      jobUrl: context.jobUrl || process.env.CI_JOB_URL || "",
+    },
+    execution: context.execution || null,
+    lifecycle: "completed",
+    system: {
+      name: results?.osName || process.platform,
+      version: results?.osVersion || "",
+    },
+    counts,
+    specs,
+    tests,
+    attachments: [],
+    trends: [],
+    generatedAt: new Date().toISOString(),
+  };
+}
+
+function writeJson(filePath, value) {
+  atomicWriteFile(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+module.exports = {
+  SCHEMA_VERSION,
+  atomicWriteFile,
+  createRunId,
+  ensureDir,
+  normalizeCypressResults,
+  safeFileName,
+  stableId,
+  writeJson,
+};