qagentic-reporter 0.1.4 → 0.1.5

package/dist/cypress/simple-setup.mjs

@@ -0,0 +1,655 @@
+import { v4 } from 'uuid';
+import * as fs2 from 'fs';
+import * as path2 from 'path';
+import axios from 'axios';
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var defaultConfig = {
+  projectName: "default",
+  environment: "local",
+  api: {
+    enabled: true,
+    url: "http://localhost:8080",
+    timeout: 3e4,
+    retryCount: 3,
+    batchSize: 100
+  },
+  local: {
+    enabled: true,
+    outputDir: "./qagentic-results",
+    formats: ["json", "html"],
+    cleanOnStart: true
+  },
+  features: {
+    aiAnalysis: true,
+    failureClustering: true,
+    flakyDetection: true,
+    screenshots: "on_failure",
+    videos: "on_failure",
+    consoleOutput: true
+  },
+  labels: {
+    custom: {}
+  }
+};
+var globalConfig = { ...defaultConfig };
+function loadFromEnv(config) {
+  const env = process.env;
+  if (env.QAGENTIC_PROJECT_NAME) {
+    config.projectName = env.QAGENTIC_PROJECT_NAME;
+  }
+  if (env.QAGENTIC_ENVIRONMENT) {
+    config.environment = env.QAGENTIC_ENVIRONMENT;
+  }
+  if (env.QAGENTIC_API_ENABLED !== void 0) {
+    config.api.enabled = env.QAGENTIC_API_ENABLED.toLowerCase() === "true";
+  }
+  if (env.QAGENTIC_API_URL) {
+    config.api.url = env.QAGENTIC_API_URL;
+  }
+  if (env.QAGENTIC_API_KEY) {
+    config.api.key = env.QAGENTIC_API_KEY;
+  }
+  if (env.QAGENTIC_LOCAL_ENABLED !== void 0) {
+    config.local.enabled = env.QAGENTIC_LOCAL_ENABLED.toLowerCase() === "true";
+  }
+  if (env.QAGENTIC_OUTPUT_DIR) {
+    config.local.outputDir = env.QAGENTIC_OUTPUT_DIR;
+  }
+  if (env.QAGENTIC_OUTPUT_FORMAT) {
+    config.local.formats = env.QAGENTIC_OUTPUT_FORMAT.split(",").map(
+      (f) => f.trim()
+    );
+  }
+  if (env.QAGENTIC_AI_ANALYSIS !== void 0) {
+    config.features.aiAnalysis = env.QAGENTIC_AI_ANALYSIS.toLowerCase() === "true";
+  }
+  if (env.QAGENTIC_SCREENSHOTS) {
+    config.features.screenshots = env.QAGENTIC_SCREENSHOTS;
+  }
+  if (env.QAGENTIC_VIDEOS) {
+    config.features.videos = env.QAGENTIC_VIDEOS;
+  }
+  if (env.QAGENTIC_TEAM) {
+    config.labels.team = env.QAGENTIC_TEAM;
+  }
+  if (env.QAGENTIC_COMPONENT) {
+    config.labels.component = env.QAGENTIC_COMPONENT;
+  }
+  return config;
+}
+function loadFromFile(filePath, config) {
+  try {
+    if (!fs2.existsSync(filePath)) {
+      return config;
+    }
+    const content = fs2.readFileSync(filePath, "utf-8");
+    const yaml = __require("yaml");
+    const data = yaml.parse(content);
+    if (data.project) {
+      if (data.project.name) config.projectName = data.project.name;
+      if (data.project.environment) config.environment = data.project.environment;
+    }
+    if (data.reporting?.api) {
+      if (data.reporting.api.enabled !== void 0) config.api.enabled = data.reporting.api.enabled;
+      if (data.reporting.api.url) config.api.url = data.reporting.api.url;
+      if (data.reporting.api.key) config.api.key = data.reporting.api.key;
+    }
+    if (data.reporting?.local) {
+      if (data.reporting.local.enabled !== void 0)
+        config.local.enabled = data.reporting.local.enabled;
+      if (data.reporting.local.output_dir) config.local.outputDir = data.reporting.local.output_dir;
+      if (data.reporting.local.formats) config.local.formats = data.reporting.local.formats;
+    }
+    if (data.features) {
+      if (data.features.ai_analysis !== void 0)
+        config.features.aiAnalysis = data.features.ai_analysis;
+      if (data.features.failure_clustering !== void 0)
+        config.features.failureClustering = data.features.failure_clustering;
+      if (data.features.flaky_detection !== void 0)
+        config.features.flakyDetection = data.features.flaky_detection;
+      if (data.features.screenshots) config.features.screenshots = data.features.screenshots;
+      if (data.features.videos) config.features.videos = data.features.videos;
+    }
+    if (data.labels) {
+      if (data.labels.team) config.labels.team = data.labels.team;
+      if (data.labels.component) config.labels.component = data.labels.component;
+      config.labels.custom = { ...config.labels.custom, ...data.labels };
+    }
+  } catch (error) {
+    console.warn(`Failed to load config from ${filePath}:`, error);
+  }
+  return config;
+}
+function autoDiscover() {
+  const config = { ...defaultConfig };
+  const cwd = process.cwd();
+  const searchPaths = [
+    path2.join(cwd, "qagentic.yaml"),
+    path2.join(cwd, "qagentic.yml"),
+    path2.join(cwd, ".qagentic.yaml"),
+    path2.join(cwd, ".qagentic.yml")
+  ];
+  for (const filePath of searchPaths) {
+    if (fs2.existsSync(filePath)) {
+      loadFromFile(filePath, config);
+      break;
+    }
+  }
+  return loadFromEnv(config);
+}
+function configure(options = {}) {
+  globalConfig = autoDiscover();
+  if (options.projectName) {
+    globalConfig.projectName = options.projectName;
+  }
+  if (options.environment) {
+    globalConfig.environment = options.environment;
+  }
+  if (options.apiUrl) {
+    globalConfig.api.url = options.apiUrl;
+  }
+  if (options.apiKey) {
+    globalConfig.api.key = options.apiKey;
+  }
+  if (options.outputDir) {
+    globalConfig.local.outputDir = options.outputDir;
+  }
+  if (options.api) {
+    globalConfig.api = { ...globalConfig.api, ...options.api };
+  }
+  if (options.local) {
+    globalConfig.local = { ...globalConfig.local, ...options.local };
+  }
+  if (options.features) {
+    globalConfig.features = { ...globalConfig.features, ...options.features };
+  }
+  if (options.labels) {
+    globalConfig.labels = { ...globalConfig.labels, ...options.labels };
+  }
+  return globalConfig;
+}
+function getConfig() {
+  return globalConfig;
+}
+
+// src/core/status.ts
+function parseStatus(value) {
+  const normalized = value.toLowerCase();
+  switch (normalized) {
+    case "passed":
+    case "pass":
+    case "success":
+      return "passed" /* PASSED */;
+    case "failed":
+    case "fail":
+    case "failure":
+      return "failed" /* FAILED */;
+    case "broken":
+    case "error":
+      return "broken" /* BROKEN */;
+    case "skipped":
+    case "skip":
+    case "pending":
+      return "skipped" /* SKIPPED */;
+    case "running":
+      return "running" /* RUNNING */;
+    default:
+      return "unknown" /* UNKNOWN */;
+  }
+}
+
+// src/core/reporter.ts
+var ConsoleReporter = class {
+  constructor(config) {
+    this.config = config || getConfig();
+  }
+  startRun(run) {
+    console.log("\n" + "=".repeat(60));
+    console.log(`\u{1F680} QAagentic Test Run - ${run.projectName}`);
+    console.log(`Environment: ${run.environment}`);
+    console.log("=".repeat(60) + "\n");
+  }
+  endRun(run) {
+    const icon = run.failed === 0 ? "\u2705" : "\u274C";
+    console.log("\n" + "=".repeat(60));
+    console.log(`${icon} Test Run Complete - ${run.passRate.toFixed(1)}% Pass Rate`);
+    console.log(`Passed: ${run.passed} | Failed: ${run.failed} | Skipped: ${run.skipped}`);
+    console.log("=".repeat(60) + "\n");
+  }
+  reportTest(test) {
+    if (!this.config.features.consoleOutput) return;
+    const symbols = {
+      ["passed" /* PASSED */]: "\u2713",
+      ["failed" /* FAILED */]: "\u2717",
+      ["broken" /* BROKEN */]: "!",
+      ["skipped" /* SKIPPED */]: "\u25CB",
+      ["pending" /* PENDING */]: "\u2026",
+      ["running" /* RUNNING */]: "\u2192",
+      ["unknown" /* UNKNOWN */]: "?"
+    };
+    const symbol = symbols[test.status] || "?";
+    console.log(`  ${symbol} ${test.name}`);
+    if (test.errorMessage) {
+      console.log(`    Error: ${test.errorMessage.slice(0, 100)}...`);
+    }
+  }
+};
+var JSONReporter = class {
+  constructor(config) {
+    this.config = config || getConfig();
+    this.outputDir = this.config.local.outputDir;
+  }
+  startRun(run) {
+    if (!fs2.existsSync(this.outputDir)) {
+      fs2.mkdirSync(this.outputDir, { recursive: true });
+    }
+    if (this.config.local.cleanOnStart) {
+      const files = fs2.readdirSync(this.outputDir);
+      for (const file of files) {
+        if (file.endsWith(".json")) {
+          fs2.unlinkSync(path2.join(this.outputDir, file));
+        }
+      }
+    }
+  }
+  endRun(run) {
+    if (!this.config.local.enabled || !this.config.local.formats.includes("json")) {
+      return;
+    }
+    const runFile = path2.join(this.outputDir, "run.json");
+    fs2.writeFileSync(runFile, JSON.stringify(this.serializeRun(run), null, 2));
+    const testsDir = path2.join(this.outputDir, "tests");
+    if (!fs2.existsSync(testsDir)) {
+      fs2.mkdirSync(testsDir, { recursive: true });
+    }
+    for (const test of run.tests) {
+      const testFile = path2.join(testsDir, `${test.id}.json`);
+      fs2.writeFileSync(testFile, JSON.stringify(this.serializeTest(test), null, 2));
+    }
+  }
+  reportTest(_test) {
+  }
+  serializeRun(run) {
+    return {
+      ...run,
+      startTime: run.startTime?.toISOString(),
+      endTime: run.endTime?.toISOString(),
+      tests: run.tests.map((t) => this.serializeTest(t))
+    };
+  }
+  serializeTest(test) {
+    return {
+      ...test,
+      startTime: test.startTime?.toISOString(),
+      endTime: test.endTime?.toISOString(),
+      steps: test.steps.map((s) => this.serializeStep(s))
+    };
+  }
+  serializeStep(step) {
+    return {
+      ...step,
+      startTime: step.startTime?.toISOString(),
+      endTime: step.endTime?.toISOString(),
+      children: step.children.map((c) => this.serializeStep(c))
+    };
+  }
+};
+var JUnitReporter = class {
+  constructor(config) {
+    this.config = config || getConfig();
+    this.outputDir = this.config.local.outputDir;
+  }
+  startRun(_run) {
+    if (!fs2.existsSync(this.outputDir)) {
+      fs2.mkdirSync(this.outputDir, { recursive: true });
+    }
+  }
+  endRun(run) {
+    if (!this.config.local.enabled || !this.config.local.formats.includes("junit")) {
+      return;
+    }
+    const xml = this.generateXml(run);
+    const junitFile = path2.join(this.outputDir, "junit.xml");
+    fs2.writeFileSync(junitFile, xml);
+  }
+  reportTest(_test) {
+  }
+  generateXml(run) {
+    const escape = (str) => str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+    let xml = '<?xml version="1.0" encoding="UTF-8"?>\n';
+    xml += `<testsuite name="${escape(run.projectName)}" `;
+    xml += `tests="${run.total}" `;
+    xml += `failures="${run.failed}" `;
+    xml += `errors="${run.broken}" `;
+    xml += `skipped="${run.skipped}" `;
+    xml += `time="${(run.durationMs / 1e3).toFixed(3)}" `;
+    xml += `timestamp="${run.startTime?.toISOString() || ""}">
+`;
+    for (const test of run.tests) {
+      xml += `  <testcase name="${escape(test.name)}" `;
+      xml += `classname="${escape(test.fullName)}" `;
+      xml += `time="${(test.durationMs / 1e3).toFixed(3)}"`;
+      if (test.status === "passed" /* PASSED */) {
+        xml += "/>\n";
+      } else if (test.status === "failed" /* FAILED */) {
+        xml += ">\n";
+        xml += `    <failure message="${escape(test.errorMessage || "Test failed")}" `;
+        xml += `type="${escape(test.errorType || "AssertionError")}">`;
+        if (test.stackTrace) {
+          xml += escape(test.stackTrace);
+        }
+        xml += "</failure>\n";
+        xml += "  </testcase>\n";
+      } else if (test.status === "broken" /* BROKEN */) {
+        xml += ">\n";
+        xml += `    <error message="${escape(test.errorMessage || "Test error")}" `;
+        xml += `type="${escape(test.errorType || "Error")}">`;
+        if (test.stackTrace) {
+          xml += escape(test.stackTrace);
+        }
+        xml += "</error>\n";
+        xml += "  </testcase>\n";
+      } else if (test.status === "skipped" /* SKIPPED */) {
+        xml += ">\n";
+        xml += `    <skipped${test.errorMessage ? ` message="${escape(test.errorMessage)}"` : ""}/>
+`;
+        xml += "  </testcase>\n";
+      } else {
+        xml += "/>\n";
+      }
+    }
+    xml += "</testsuite>\n";
+    return xml;
+  }
+};
+var APIReporter = class {
+  constructor(config) {
+    this.batch = [];
+    this.config = config || getConfig();
+  }
+  async startRun(run) {
+    if (!this.config.api.enabled) return;
+    this.currentRun = run;
+    this.batch = [];
+    try {
+      await axios.post(
+        `${this.config.api.url}/api/v1/runs`,
+        {
+          id: run.id,
+          name: run.name,
+          project_name: run.projectName,
+          environment: run.environment,
+          start_time: run.startTime?.toISOString(),
+          labels: run.labels,
+          ci_build_id: run.ciBuildId,
+          branch: run.branch,
+          commit_hash: run.commitHash
+        },
+        {
+          headers: {
+            "Content-Type": "application/json",
+            "X-API-Key": this.config.api.key || "",
+            "X-Project": this.config.projectName
+          },
+          timeout: this.config.api.timeout
+        }
+      );
+    } catch (error) {
+      console.warn("Warning: Failed to register run with API:", error);
+    }
+  }
+  async endRun(run) {
+    if (!this.config.api.enabled) return;
+    await this.flushBatch();
+    try {
+      await axios.patch(
+        `${this.config.api.url}/api/v1/runs/${run.id}`,
+        {
+          end_time: run.endTime?.toISOString(),
+          duration_ms: run.durationMs,
+          total: run.total,
+          passed: run.passed,
+          failed: run.failed,
+          broken: run.broken,
+          skipped: run.skipped,
+          status: "completed"
+        },
+        {
+          headers: {
+            "Content-Type": "application/json",
+            "X-API-Key": this.config.api.key || ""
+          },
+          timeout: this.config.api.timeout
+        }
+      );
+    } catch (error) {
+      console.warn("Warning: Failed to finalize run with API:", error);
+    }
+  }
+  async reportTest(test) {
+    if (!this.config.api.enabled) return;
+    this.batch.push(test);
+    if (this.batch.length >= this.config.api.batchSize) {
+      await this.flushBatch();
+    }
+  }
+  async flushBatch() {
+    if (this.batch.length === 0 || !this.currentRun) return;
+    try {
+      await axios.post(
+        `${this.config.api.url}/api/v1/runs/${this.currentRun.id}/results`,
+        this.batch.map((t) => ({
+          ...t,
+          startTime: t.startTime?.toISOString(),
+          endTime: t.endTime?.toISOString()
+        })),
+        {
+          headers: {
+            "Content-Type": "application/json",
+            "X-API-Key": this.config.api.key || ""
+          },
+          timeout: this.config.api.timeout
+        }
+      );
+    } catch (error) {
+      console.warn("Warning: Failed to send test results to API:", error);
+    } finally {
+      this.batch = [];
+    }
+  }
+};
+var _QAgenticReporter = class _QAgenticReporter {
+  constructor(config) {
+    this.reporters = [];
+    this.currentRun = null;
+    this.config = config || getConfig();
+    if (this.config.features.consoleOutput) {
+      this.reporters.push(new ConsoleReporter(this.config));
+    }
+    if (this.config.local.enabled) {
+      this.reporters.push(new JSONReporter(this.config));
+      if (this.config.local.formats.includes("junit")) {
+        this.reporters.push(new JUnitReporter(this.config));
+      }
+    }
+    if (this.config.api.enabled) {
+      this.reporters.push(new APIReporter(this.config));
+    }
+  }
+  /**
+   * Get singleton instance.
+   */
+  static getInstance(config) {
+    if (!_QAgenticReporter.instance) {
+      _QAgenticReporter.instance = new _QAgenticReporter(config);
+    }
+    return _QAgenticReporter.instance;
+  }
+  /**
+   * Reset singleton instance.
+   */
+  static reset() {
+    _QAgenticReporter.instance = null;
+  }
+  /**
+   * Start a new test run.
+   */
+  async startRun(options = {}) {
+    this.currentRun = {
+      id: options.id || v4(),
+      name: options.name || `run_${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "")}`,
+      projectName: options.projectName || this.config.projectName,
+      environment: options.environment || this.config.environment,
+      startTime: /* @__PURE__ */ new Date(),
+      durationMs: 0,
+      tests: [],
+      total: 0,
+      passed: 0,
+      failed: 0,
+      broken: 0,
+      skipped: 0,
+      passRate: 0,
+      labels: { ...this.config.labels.custom, ...options.labels },
+      parameters: options.parameters || {},
+      ciBuildId: options.ciBuildId,
+      ciBuildUrl: options.ciBuildUrl,
+      branch: options.branch,
+      commitHash: options.commitHash
+    };
+    for (const reporter of this.reporters) {
+      await reporter.startRun(this.currentRun);
+    }
+    return this.currentRun;
+  }
+  /**
+   * End the current test run.
+   */
+  async endRun() {
+    if (!this.currentRun) return null;
+    this.currentRun.endTime = /* @__PURE__ */ new Date();
+    this.currentRun.durationMs = this.currentRun.endTime.getTime() - (this.currentRun.startTime?.getTime() || 0);
+    this.currentRun.passRate = this.currentRun.total > 0 ? this.currentRun.passed / this.currentRun.total * 100 : 0;
+    for (const reporter of this.reporters) {
+      await reporter.endRun(this.currentRun);
+    }
+    const run = this.currentRun;
+    this.currentRun = null;
+    return run;
+  }
+  /**
+   * Report a test result.
+   */
+  async reportTest(test) {
+    if (this.currentRun) {
+      this.currentRun.tests.push(test);
+      this.currentRun.total++;
+      switch (test.status) {
+        case "passed" /* PASSED */:
+          this.currentRun.passed++;
+          break;
+        case "failed" /* FAILED */:
+          this.currentRun.failed++;
+          break;
+        case "broken" /* BROKEN */:
+          this.currentRun.broken++;
+          break;
+        case "skipped" /* SKIPPED */:
+          this.currentRun.skipped++;
+          break;
+      }
+    }
+    for (const reporter of this.reporters) {
+      await reporter.reportTest(test);
+    }
+  }
+  /**
+   * Get the current test run.
+   */
+  getCurrentRun() {
+    return this.currentRun;
+  }
+};
+_QAgenticReporter.instance = null;
+var QAgenticReporter = _QAgenticReporter;
+
+// src/cypress/simple-setup.ts
+function setupQAgentic(on, config) {
+  const projectName = process.env.QAGENTIC_PROJECT_NAME || config.projectId || "Cypress E2E Tests";
+  const environment = process.env.QAGENTIC_ENVIRONMENT || process.env.NODE_ENV || "e2e";
+  const apiUrl = process.env.QAGENTIC_API_URL || "http://localhost:8080";
+  configure({
+    projectName,
+    environment,
+    apiUrl,
+    outputDir: "./qagentic-results"
+  });
+  const reporter = QAgenticReporter.getInstance();
+  let currentRun = null;
+  on("before:run", async () => {
+    try {
+      currentRun = await reporter.startRun({
+        name: `cypress_${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "")}`,
+        projectName,
+        environment
+      });
+      console.log("[QAagentic] Test run started successfully");
+    } catch (error) {
+      console.warn("[QAagentic] Failed to start run:", error);
+    }
+  });
+  on("after:spec", async (_spec, results) => {
+    if (!results?.tests) return;
+    for (const test of results.tests) {
+      try {
+        const testResult = {
+          id: v4(),
+          name: test.title[test.title.length - 1],
+          fullName: test.title.join(" > "),
+          status: parseStatus(test.state),
+          durationMs: test.duration,
+          startTime: new Date(Date.now() - test.duration),
+          endTime: /* @__PURE__ */ new Date(),
+          labels: {
+            suite: test.title.slice(0, -1).join(" > "),
+            feature: test.title[0]
+          },
+          links: [],
+          parameters: {},
+          steps: [],
+          attachments: [],
+          filePath: results.spec.relative,
+          retryCount: 0,
+          isRetry: false,
+          isFlaky: false
+        };
+        if (test.err) {
+          testResult.errorMessage = test.err.message;
+          testResult.stackTrace = test.err.stack;
+          testResult.errorType = "AssertionError";
+        }
+        await reporter.reportTest(testResult);
+      } catch (error) {
+        console.warn("[QAagentic] Failed to report test:", error);
+      }
+    }
+  });
+  on("after:run", async () => {
+    try {
+      await reporter.endRun();
+      console.log("[QAagentic] Test run completed");
+    } catch (error) {
+      console.warn("[QAagentic] Failed to end run:", error);
+    }
+  });
+}
+var simple_setup_default = setupQAgentic;
+
+export { simple_setup_default as default, setupQAgentic };
+//# sourceMappingURL=simple-setup.mjs.map
+//# sourceMappingURL=simple-setup.mjs.map