@msalaam/xray-qe-toolkit 1.4.1 → 1.6.0

package/commands/createPlan.js

@@ -12,7 +12,7 @@
 import fs from "node:fs";
 import logger, { setVerbose } from "../lib/logger.js";
 import { loadConfig, validateConfig } from "../lib/config.js";
-import { authenticate, createTestPlan } from "../lib/xrayClient.js";
+import { authenticate, createIssue, createTestPlan, getIssue } from "../lib/xrayClient.js";
 
 export default async function createPlan(opts = {}) {
   if (opts.verbose) setVerbose(true);
@@ -42,47 +42,36 @@ export default async function createPlan(opts = {}) {
 
   let planKey;
   try {
-    const jiraPayload = {
-      fields: {
-        project: { key: cfg.jiraProjectKey },
-        summary,
-        issuetype: { name: "Test Plan" },
-        ...(opts.version && {
-          fixVersions: [{ name: opts.version }],
-        }),
-        ...(opts.label && {
-          labels: opts.label.split(",").map((l) => l.trim()),
-        }),
-      },
+    const fields = {
+      summary,
+      description: summary,
+      ...(opts.label && {
+        labels: opts.label.split(",").map((l) => l.trim()),
+      }),
     };
 
-    const response = await fetch(`${cfg.jiraUrl}/rest/api/3/issue`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Basic ${Buffer.from(`${cfg.jiraEmail}:${cfg.jiraApiToken}`).toString("base64")}`,
-      },
-      body: JSON.stringify(jiraPayload),
-    });
-
-    if (!response.ok) {
-      const body = await response.text();
-      throw new Error(`JIRA returned ${response.status}: ${body}`);
-    }
-
-    const data = await response.json();
-    planKey = data.key;
+    const issue = await createIssue(cfg, "Test Plan", fields);
+    planKey = issue.key;
   } catch (err) {
     // Fallback: try via Xray GraphQL createTestPlan mutation
     logger.debug(`JIRA REST failed, trying Xray GraphQL: ${err.message}`);
     try {
       const result = await createTestPlan(cfg, xrayToken, {
-        jira: {
-          summary,
-          project: { key: cfg.jiraProjectKey },
-        },
+        projectId: cfg.jiraProjectKey,
+        summary,
+        description: summary,
       });
-      planKey = result?.createTestPlan?.testPlan?.jira?.key;
+
+      // GraphQL returns { testPlan: { issueId, projectId } } — resolve key via JIRA
+      const issueId = result?.testPlan?.issueId;
+      if (issueId) {
+        try {
+          const issue = await getIssue(cfg, issueId);
+          planKey = issue?.key;
+        } catch {
+          logger.debug(`Could not resolve JIRA key for issueId ${issueId}`);
+        }
+      }
     } catch (gqlErr) {
       logger.error(`Could not create Test Plan: ${gqlErr.message}`);
       process.exit(1);

package/commands/importResults.js

@@ -88,6 +88,7 @@ export default async function importResults(opts = {}) {
     ...(!execKey && planKey && { testPlanKey: planKey }),
     ...(opts.version && { version: opts.version }),
     ...(opts.revision && { revision: opts.revision }),
+    ...(opts.fixVersion && { fixVersion: opts.fixVersion }),
   };
 
   let result;
@@ -101,6 +102,7 @@ export default async function importResults(opts = {}) {
 
     xrayJson = convertPlaywrightToXray(playwrightJson, {
       projectKey: cfg.jiraProjectKey,
+      statusMapping: cfg.statusMapping || undefined,
       infoOverrides: infoBase,
     });
 

package/commands/init.js

@@ -200,6 +200,8 @@ export default async function init(opts = {}) {
       environments: ["IOP-DEV", "IOP-QA", "IOP-PROD"],
       folderRoot: `/${serviceName}`,
       xrayRegion: "us",
+      bulkImportThreshold: 50,
+      // statusMapping: { interrupted: "ABORTED", skipped: "TODO" }
     };
     fs.writeFileSync(xrayrcPath, JSON.stringify(xrayrc, null, 2));
     logger.success(".xrayrc created — Project config");

package/commands/pushTests.js

@@ -8,8 +8,10 @@
  *   1. Load & validate config + tests.json
  *   2. Authenticate with Xray (once)
  *   3. Build & push tests (create/update via GraphQL)
- *   4. Sync Test Plan membership (add new keys, remove old)
- *   5. Sync Xray folder structure from test `folder` fields
+ *   4. Sync Test Sets — create sets by testSet name, add tests (mapping._testSets)
+ *   5. Sync Test Plan membership (add new keys)
+ *   6. Sync Xray folder structure from test `folder` fields
+ *   7. Optionally create a Test Execution linked to the plan
  *   6. Save mapping
  */
 
@@ -17,11 +19,13 @@ import fs from "node:fs";
 import { createRequire } from "node:module";
 import logger, { setVerbose } from "../lib/logger.js";
 import { loadConfig, validateConfig } from "../lib/config.js";
-import { authenticate, getIssue } from "../lib/xrayClient.js";
+import { readJsonFile } from "../lib/jsonFile.js";
+import { authenticate, getIssue, createTestExecution } from "../lib/xrayClient.js";
 import {
   buildAndPush,
   loadMapping,
   saveMapping,
+  syncTestSets,
   syncTestPlan,
   syncFolders,
 } from "../lib/testCaseBuilder.js";
@@ -41,7 +45,7 @@ export default async function pushTests(opts = {}) {
     process.exit(1);
   }
 
-  const testsConfig = JSON.parse(fs.readFileSync(cfg.testsPath, "utf8"));
+  const testsConfig = readJsonFile(cfg.testsPath);
   const allTests = testsConfig.tests || [];
   const tests = allTests.filter((t) => !t.skip);
   const skippedCount = allTests.length - tests.length;
@@ -58,9 +62,7 @@ export default async function pushTests(opts = {}) {
   try {
     const require = createRequire(import.meta.url);
     const Ajv = require("ajv");
-    const schema = JSON.parse(
-      fs.readFileSync(new URL("../schema/tests.schema.json", import.meta.url), "utf8")
-    );
+    const schema = readJsonFile(new URL("../schema/tests.schema.json", import.meta.url));
     const ajv = new Ajv({ allErrors: true });
     const validate = ajv.compile(schema);
     if (!validate(testsConfig)) {
@@ -99,6 +101,31 @@ export default async function pushTests(opts = {}) {
   saveMapping(cfg.mappingPath, mapping);
   logger.save(`Mapping saved to ${cfg.mappingPath}`);
 
+  // ── Sync Test Sets ──────────────────────────────────────────────────
+  const testsWithSets = tests.filter((t) => t.testSet && (Array.isArray(t.testSet) ? t.testSet.length > 0 : true));
+
+  if (testsWithSets.length > 0) {
+    logger.blank();
+    const uniqueSets = [...new Set(testsWithSets.flatMap((t) => Array.isArray(t.testSet) ? t.testSet : [t.testSet]))];
+    logger.send(`Syncing ${uniqueSets.length} Test Set(s) (${testsWithSets.length} test(s))...`);
+    try {
+      const setResult = await syncTestSets(cfg, xrayToken, tests, mapping, cfg.mappingPath);
+      logger.success(
+        `Test Sets: ${setResult.created} created, ${setResult.synced} test(s) assigned` +
+        (setResult.failed.length > 0 ? `, ${setResult.failed.length} failed` : "")
+      );
+      if (setResult.failed.length > 0) {
+        for (const name of setResult.failed) {
+          logger.warn(`  FAILED: Test Set "${name}"`);
+        }
+      }
+    } catch (err) {
+      logger.warn(`Test Set sync failed: ${err.message}`);
+    }
+  } else {
+    logger.debug("No testSet fields — skipping Test Set sync");
+  }
+
   // ── Sync Test Plan ─────────────────────────────────────────────────────────
   const planKey = opts.plan || cfg.testPlanKey || testsConfig.testPlan?.key;
 
@@ -151,6 +178,37 @@ export default async function pushTests(opts = {}) {
     logger.debug("No folder fields — skipping folder sync");
   }
 
+  // ── Create Test Execution (optional) ───────────────────────────────────────
+  if (opts.createExecution && planKey) {
+    logger.blank();
+    logger.send("Creating Test Execution linked to Test Plan...");
+    try {
+      const environment = opts.executionEnv || cfg.defaultEnvironment || "IOP-DEV";
+      const testIssueIds = Object.values(mapping)
+        .filter((v) => v.id && !String(v.id).startsWith("_"))
+        .map((v) => String(v.id));
+
+      const execSummary =
+        opts.executionSummary ||
+        `${environment} Test Run — ${new Date().toLocaleString()}`;
+
+      const { key: execKey } = await createTestExecution(cfg, xrayToken, {
+        summary: execSummary,
+        environments: [environment],
+        testIssueIds,
+        testPlanKey: planKey,
+      });
+
+      logger.success(`Test Execution created: ${execKey}`);
+      logger.link(`${cfg.jiraUrl}/browse/${execKey}`);
+    } catch (err) {
+      logger.warn(`Test Execution creation failed: ${err.message}`);
+    }
+  } else if (opts.createExecution && !planKey) {
+    logger.blank();
+    logger.warn("--create-execution requires a Test Plan key (--plan or .xrayrc testPlanKey)");
+  }
+
   logger.blank();
   logger.success("push-tests complete");
   logger.blank();

package/lib/config.js

@@ -97,6 +97,13 @@ export function loadConfig(opts = {}) {
     environments: rcConfig.environments || defaultEnvironments,
     folderRoot: rcConfig.folderRoot || null,
 
+    // Playwright status mapping (overrides defaults per-project)
+    // e.g. { "interrupted": "ABORTED", "skipped": "TODO" }
+    statusMapping: rcConfig.statusMapping || null,
+
+    // Bulk import threshold — use Xray REST bulk API when creating this many new tests
+    bulkImportThreshold: Number(process.env.XQT_BULK_THRESHOLD ?? rcConfig.bulkImportThreshold ?? 50),
+
     // Paths (resolved relative to consuming project)
     testsPath: path.resolve(cwd, rcConfig.testsPath || "tests.json"),
     mappingPath: path.resolve(cwd, rcConfig.mappingPath || "xray-mapping.json"),

package/lib/jsonFile.js

@@ -0,0 +1,12 @@
+import fs from "node:fs";
+
+/**
+ * Parse a JSON file and tolerate UTF-8 BOM at file start.
+ * @param {string | URL} filePath
+ * @returns {any}
+ */
+export function readJsonFile(filePath) {
+  const raw = fs.readFileSync(filePath, "utf8");
+  const content = raw.charCodeAt(0) === 0xfeff ? raw.slice(1) : raw;
+  return JSON.parse(content);
+}

package/lib/playwrightConverter.js

@@ -20,8 +20,10 @@ import path from "node:path";
  * @param {object} playwrightJson - Playwright JSON reporter output
  * @param {object} options - Conversion options
  * @param {string} [options.projectKey]    - JIRA project key (for new test creation)
+ * @param {object} [options.statusMapping] - Override default Playwright→Xray status map
+ *   e.g. { interrupted: "ABORTED", skipped: "TODO" }
  * @param {object} [options.infoOverrides] - Merged into the Xray `info` object:
- *   testPlanKey, testEnvironments, version, revision, summary, description
+ *   testPlanKey, testEnvironments, version, revision, fixVersion, summary, description
  * @returns {object} Xray JSON format ready for import
  */
 export function convertPlaywrightToXray(playwrightJson, options = {}) {
@@ -110,7 +112,7 @@ function convertTest(test, spec, suite, options) {
   const result = test.results[test.results.length - 1];
 
   const testKey = extractTestKey(spec.title, test.annotations);
-  const status = mapStatus(result.status);
+  const status = mapStatus(result.status, options.statusMapping);
 
   const xrayTest = {
     status,
@@ -145,14 +147,16 @@ function convertTest(test, spec, suite, options) {
   }
 
   // ── Map Playwright steps to Xray step results ─────────────────────────────
-  if (result.steps && result.steps.length > 0) {
-    xrayTest.steps = result.steps
-      .filter((s) => s.category === "test.step" || s.category === "hook")
-      .map((s) => ({
-        status: s.error ? "FAILED" : "PASSED",
-        comment: s.title || s.category,
-        ...(s.duration && { duration: Math.round(s.duration) }),
-      }));
+  const relevantSteps = result.steps
+    ? result.steps.filter((s) => s.category === "test.step" || s.category === "hook")
+    : [];
+
+  if (relevantSteps.length > 0) {
+    xrayTest.steps = relevantSteps.map((s) => ({
+      status: s.error ? "FAILED" : "PASSED",
+      comment: s.title || s.category,
+      ...(s.duration && { duration: Math.round(s.duration) }),
+    }));
   }
 
   // ── Error details ──────────────────────────────────────────────────────────
@@ -162,35 +166,34 @@ function convertTest(test, spec, suite, options) {
     xrayTest.comment += `\n\nError: ${msg}${stack}`;
   }
 
-  // ── Attachments / Evidence ────────────────────────────────────────────────
+  // ── Attachments / Evidence (with per-step attachment for screenshots) ──────
   if (result.attachments && result.attachments.length > 0) {
-    xrayTest.evidence = [];
-    for (const attachment of result.attachments) {
-      let data = null;
-
-      if (attachment.body) {
-        // In-memory body (Buffer from Playwright)
-        data = Buffer.isBuffer(attachment.body)
-          ? attachment.body.toString("base64")
-          : Buffer.from(attachment.body).toString("base64");
-      } else if (attachment.path && fs.existsSync(attachment.path)) {
-        // File on disk
-        data = fs.readFileSync(attachment.path).toString("base64");
-      }
+    const screenshots = result.attachments.filter(
+      (a) => a.contentType?.startsWith("image/") || a.name?.match(/screenshot/i)
+    );
+    const traces = result.attachments.filter((a) => a.name?.match(/trace/i));
+    const other = result.attachments.filter(
+      (a) => !screenshots.includes(a) && !traces.includes(a)
+    );
 
-      if (data) {
-        xrayTest.evidence.push({
-          filename: attachment.name || path.basename(attachment.path || "attachment"),
-          contentType: attachment.contentType || "application/octet-stream",
-          data,
-        });
-      }
+    // Find the last failed step index for per-step evidence attachment
+    const lastFailedStepIdx =
+      relevantSteps.reduce((acc, s, i) => (s.error ? i : acc), -1);
+
+    // Attach screenshots to the last failed step (per-step evidence)
+    if (xrayTest.steps && lastFailedStepIdx >= 0 && screenshots.length > 0) {
+      xrayTest.steps[lastFailedStepIdx].evidences = screenshots
+        .map((a) => buildEvidenceItem(a))
+        .filter(Boolean);
     }
 
-    if (xrayTest.evidence.length > 0) {
-      xrayTest.comment += `\n\nAttachments: ${result.attachments.map((a) => a.name).join(", ")}`;
-    } else {
-      delete xrayTest.evidence;
+    // Everything else (traces, other) stays at test level
+    const testLevelAttachments = [...(lastFailedStepIdx >= 0 ? [] : screenshots), ...traces, ...other];
+    const testLevelEvidence = testLevelAttachments.map((a) => buildEvidenceItem(a)).filter(Boolean);
+
+    if (testLevelEvidence.length > 0) {
+      xrayTest.evidence = testLevelEvidence;
+      xrayTest.comment += `\n\nAttachments: ${testLevelAttachments.map((a) => a.name).join(", ")}`;
     }
   }
 
@@ -209,16 +212,36 @@ function extractTestKey(title, annotations) {
   return match ? match[1] : null;
 }
 
-function mapStatus(playwrightStatus) {
-  return (
-    {
-      passed: "PASSED",
-      failed: "FAILED",
-      timedOut: "FAILED",
-      interrupted: "ABORTED",
-      skipped: "TODO",
-    }[playwrightStatus] || "TODO"
-  );
+function mapStatus(playwrightStatus, customMapping) {
+  const defaults = {
+    passed: "PASSED",
+    failed: "FAILED",
+    timedOut: "FAILED",
+    interrupted: "ABORTED",
+    skipped: "TODO",
+  };
+  const map = customMapping ? { ...defaults, ...customMapping } : defaults;
+  return map[playwrightStatus] || "TODO";
+}
+
+function buildEvidenceItem(attachment) {
+  let data = null;
+
+  if (attachment.body) {
+    data = Buffer.isBuffer(attachment.body)
+      ? attachment.body.toString("base64")
+      : Buffer.from(attachment.body).toString("base64");
+  } else if (attachment.path && fs.existsSync(attachment.path)) {
+    data = fs.readFileSync(attachment.path).toString("base64");
+  }
+
+  if (!data) return null;
+
+  return {
+    filename: attachment.name || path.basename(attachment.path || "attachment"),
+    contentType: attachment.contentType || "application/octet-stream",
+    data,
+  };
 }
 
 function buildComment(result, spec, suite) {