testcomplete-qatouch 1.0.0

package/README.md

@@ -0,0 +1,76 @@
+# testcomplete-qatouch
+
+> QA Touch reporter for **TestComplete** (SmartBear).
+> Reads JUnit XML files exported from TestComplete and automatically creates
+> modules, test cases, and a test run in QA Touch.
+
+## Install
+
+```bash
+npm install testcomplete-qatouch
+```
+
+No peer dependencies — works with any Node.js >= 16 project.
+
+## Usage
+
+Export results from TestComplete via **File > Export > JUnit XML** (or use the
+`tcDumpJUnit` CLI utility), then create an `upload-results.ts` file:
+
+```ts
+import { TestCompleteQATouchReporter } from "testcomplete-qatouch";
+
+const reporter = new TestCompleteQATouchReporter({
+  domain:       "mycompany",
+  apiToken:     "YOUR_API_TOKEN",
+  projectKey:   "PROJ",
+  assignTo:     "user-key",
+  resultsFile:  "./TestResults/junit.xml",
+  milestoneName: "Sprint 12",
+  tag:          "testcomplete",
+});
+
+await reporter.run();
+```
+
+Run it:
+
+```bash
+npx ts-node upload-results.ts
+```
+
+## Options
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `domain` | `string` | — | QA Touch subdomain |
+| `apiToken` | `string` | — | QA Touch API token |
+| `projectKey` | `string` | — | QA Touch project key |
+| `assignTo` | `string` | — | User key to assign the test run |
+| `resultsFile` | `string` | — | Path to the JUnit XML file |
+| `testsuiteId` | `string?` | auto | Fixed module key — skips auto-create |
+| `milestoneName` | `string?` | `"TestComplete Automation"` | Milestone name |
+| `milestoneKey` | `string?` | — | Existing milestone key |
+| `createCases` | `boolean?` | `true` | Auto-create missing test cases |
+| `tag` | `string?` | `"testcomplete"` | Tag applied to the test run |
+
+## How to export JUnit XML from TestComplete
+
+1. Run your TestComplete project suite.
+2. **File > Export > JUnit XML Report** — or use the CLI:
+   ```
+   tcDumpJUnit /results:"%TESTCOMPLETE_LOG%" /output:"TestResults\junit.xml"
+   ```
+3. Point `resultsFile` at the output file.
+
+## CI example
+
+```yaml
+- name: Run TestComplete tests
+  run: |
+    "C:\Program Files\SmartBear\TestComplete\bin\TestComplete.exe" MyProject.pjs /run /exit
+    tcDumpJUnit /results:"%TC_LOG_FILE%" /output:"TestResults\junit.xml"
+
+- name: Upload to QA Touch
+  run: npx ts-node upload-results.ts
+```

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { TestCompleteQATouchReporter } from "./reporter";
+export type { TestCompleteQATouchReporterOptions } from "./reporter";

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestCompleteQATouchReporter = void 0;
+var reporter_1 = require("./reporter");
+Object.defineProperty(exports, "TestCompleteQATouchReporter", { enumerable: true, get: function () { return reporter_1.TestCompleteQATouchReporter; } });

package/dist/qatouch-client.d.ts

@@ -0,0 +1,27 @@
+export interface QATouchClientOptions {
+    domain: string;
+    apiToken: string;
+    projectKey: string;
+}
+export declare class QATouchClient {
+    private domain;
+    private apiToken;
+    private projectKey;
+    constructor(options: QATouchClientOptions);
+    private request;
+    private multipartRequest;
+    private normalizeList;
+    getTestCases(moduleKey?: string): Promise<any[]>;
+    createTestCase(moduleKey: string, title: string, description: string, reference: string, precondition: string, stepsTemplate: string): Promise<void>;
+    getModules(): Promise<any[]>;
+    createModule(moduleName: string, parentKey?: string): Promise<any>;
+    getMilestones(): Promise<any[]>;
+    createMilestone(name: string): Promise<void>;
+    createTestRun(milestoneKey: string, title: string, assignTo: string, caseKeys: string[], tags?: string): Promise<any>;
+    createTestRunByModules(milestoneKey: string, title: string, assignTo: string, moduleKeys: string[], tags?: string): Promise<any>;
+    updateResults(testRunKey: string, results: Array<{
+        case: string;
+        status: number;
+    }>): Promise<any>;
+    addResultWithComment(testRunKey: string, caseKey: string, statusId: number, comments?: string, screenshotPath?: string): Promise<any>;
+}

package/dist/qatouch-client.js

@@ -0,0 +1,286 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QATouchClient = void 0;
+const https = __importStar(require("https"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class QATouchClient {
+    constructor(options) {
+        this.domain = options.domain;
+        this.apiToken = options.apiToken;
+        this.projectKey = options.projectKey;
+    }
+    request(method, endpoint) {
+        return new Promise((resolve, reject) => {
+            const headers = {
+                "api-token": this.apiToken,
+                domain: this.domain,
+                "Content-Type": "application/json",
+            };
+            if (method !== "GET") {
+                headers["Content-Length"] = "0";
+            }
+            const req = https.request({
+                hostname: "api.qatouch.com",
+                path: `/api/v1${endpoint}`,
+                method,
+                headers,
+            }, (res) => {
+                let body = "";
+                res.on("data", (chunk) => {
+                    body += chunk;
+                });
+                res.on("end", () => {
+                    let parsed = {};
+                    if (body) {
+                        try {
+                            parsed = JSON.parse(body);
+                        }
+                        catch {
+                            reject(new Error(`Non-JSON response (${res.statusCode}) for ${endpoint}`));
+                            return;
+                        }
+                    }
+                    if (res.statusCode >= 200 && res.statusCode < 300) {
+                        resolve(parsed);
+                        return;
+                    }
+                    reject(new Error(parsed.error_msg ||
+                        parsed.error ||
+                        `API Error ${res.statusCode} for ${endpoint}`));
+                });
+            });
+            req.on("error", reject);
+            req.end();
+        });
+    }
+    multipartRequest(endpoint, filePath) {
+        return new Promise((resolve, reject) => {
+            const boundary = `----QATouchBoundary${Date.now()}`;
+            const fileName = path.basename(filePath);
+            const fileData = fs.readFileSync(filePath);
+            const preamble = Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="file[]"; filename="${fileName}"\r\nContent-Type: application/octet-stream\r\n\r\n`);
+            const epilogue = Buffer.from(`\r\n--${boundary}--\r\n`);
+            const body = Buffer.concat([preamble, fileData, epilogue]);
+            const req = https.request({
+                hostname: "api.qatouch.com",
+                path: `/api/v1${endpoint}`,
+                method: "POST",
+                headers: {
+                    "api-token": this.apiToken,
+                    domain: this.domain,
+                    "Content-Type": `multipart/form-data; boundary=${boundary}`,
+                    "Content-Length": body.length,
+                },
+            }, (res) => {
+                let resBody = "";
+                res.on("data", (chunk) => {
+                    resBody += chunk;
+                });
+                res.on("end", () => {
+                    let parsed = {};
+                    if (resBody) {
+                        try {
+                            parsed = JSON.parse(resBody);
+                        }
+                        catch {
+                            reject(new Error(`Non-JSON response (${res.statusCode}) for ${endpoint}`));
+                            return;
+                        }
+                    }
+                    if (res.statusCode >= 200 && res.statusCode < 300) {
+                        resolve(parsed);
+                        return;
+                    }
+                    reject(new Error(parsed.error_msg ||
+                        parsed.error ||
+                        `API Error ${res.statusCode} for ${endpoint}`));
+                });
+            });
+            req.on("error", reject);
+            req.write(body);
+            req.end();
+        });
+    }
+    normalizeList(response) {
+        if (Array.isArray(response))
+            return response;
+        if (Array.isArray(response.data))
+            return response.data;
+        if (Array.isArray(response.items))
+            return response.items;
+        return [];
+    }
+    async getTestCases(moduleKey) {
+        const all = [];
+        let page = 1;
+        for (;;) {
+            const query = moduleKey
+                ? `moduleKey=${moduleKey}&page=${page}`
+                : `mode=automation&page=${page}`;
+            const response = await this.request("GET", `/getAllTestCases/${this.projectKey}?${query}`);
+            const batch = this.normalizeList(response);
+            if (batch.length === 0)
+                break;
+            all.push(...batch);
+            const total = Number(response?.meta?.total) || 0;
+            if (total > 0 && all.length >= total)
+                break;
+            if (batch.length < Number(response?.meta?.per_page || 50))
+                break;
+            page++;
+            if (page > 200)
+                break;
+        }
+        return all;
+    }
+    async createTestCase(moduleKey, title, description, reference, precondition, stepsTemplate) {
+        const endpoint = `/testCase/steps?projectKey=${this.projectKey}&sectionKey=${moduleKey}&caseTitle=${encodeURIComponent(title)}&description=${encodeURIComponent(description)}&reference=${encodeURIComponent(reference)}&precondition=${encodeURIComponent(precondition)}&steps_template=${stepsTemplate}&mode=automation`;
+        await this.request("POST", endpoint);
+    }
+    async getModules() {
+        const all = [];
+        let page = 1;
+        for (;;) {
+            const response = await this.request("GET", `/getAllModules/${this.projectKey}?page=${page}`);
+            const batch = this.normalizeList(response);
+            if (batch.length === 0)
+                break;
+            all.push(...batch);
+            const total = Number(response?.meta?.total) || 0;
+            if (total > 0 && all.length >= total)
+                break;
+            if (batch.length < Number(response?.meta?.per_page || 20))
+                break;
+            page++;
+            if (page > 50)
+                break;
+        }
+        return all;
+    }
+    async createModule(moduleName, parentKey) {
+        let endpoint = `/module?projectKey=${this.projectKey}&moduleName=${encodeURIComponent(moduleName)}`;
+        if (parentKey) {
+            endpoint += `&parentKey=${encodeURIComponent(parentKey)}`;
+        }
+        const response = await this.request("POST", endpoint);
+        if (response?.data && typeof response.data === "object" && !Array.isArray(response.data)) {
+            return response.data;
+        }
+        const list = this.normalizeList(response);
+        return list.length > 0 ? list[0] : response;
+    }
+    async getMilestones() {
+        const response = await this.request("GET", `/getAllMilestones/${this.projectKey}`);
+        return this.normalizeList(response);
+    }
+    async createMilestone(name) {
+        await this.request("POST", `/milestone?projectKey=${this.projectKey}&milestone=${encodeURIComponent(name)}`);
+    }
+    async createTestRun(milestoneKey, title, assignTo, caseKeys, tags) {
+        const params = [
+            `projectKey=${this.projectKey}`,
+            `milestoneKey=${encodeURIComponent(milestoneKey)}`,
+            `testRun=${encodeURIComponent(title)}`,
+            `assignTo=${encodeURIComponent(assignTo)}`,
+        ];
+        if (tags)
+            params.push(`tags=${encodeURIComponent(tags)}`);
+        for (const key of caseKeys) {
+            params.push(`caseId[]=${encodeURIComponent(key)}`);
+        }
+        const response = await this.request("POST", `/testRun/specific?${params.join("&")}`);
+        const payload = this.normalizeList(response)[0] ||
+            response.data?.[0] ||
+            response.data ||
+            {};
+        return payload;
+    }
+    async createTestRunByModules(milestoneKey, title, assignTo, moduleKeys, tags) {
+        const params = [
+            `projectKey=${this.projectKey}`,
+            `milestoneKey=${encodeURIComponent(milestoneKey)}`,
+            `testRun=${encodeURIComponent(title)}`,
+            `assignTo=${encodeURIComponent(assignTo)}`,
+            `mode=automation`,
+        ];
+        if (tags)
+            params.push(`tags=${encodeURIComponent(tags)}`);
+        for (const key of moduleKeys) {
+            params.push(`moduleKey[]=${encodeURIComponent(key)}`);
+        }
+        const response = await this.request("POST", `/testRun/specific/module/mode?${params.join("&")}`);
+        const payload = this.normalizeList(response)[0] ||
+            response.data?.[0] ||
+            response.data ||
+            {};
+        return payload;
+    }
+    async updateResults(testRunKey, results) {
+        const casesObj = {};
+        results.forEach((r, i) => {
+            casesObj[String(i)] = r;
+        });
+        const endpoint = `/runresult/updatestatus/multiple?project=${this.projectKey}&test_run=${testRunKey}&cases=${encodeURIComponent(JSON.stringify(casesObj))}`;
+        return this.request("POST", endpoint);
+    }
+    async addResultWithComment(testRunKey, caseKey, statusId, comments, screenshotPath) {
+        const statusName = statusIdToName(statusId);
+        let endpoint = `/testRunResults/add/results?status=${encodeURIComponent(statusName)}&project=${encodeURIComponent(this.projectKey)}&test_run=${encodeURIComponent(testRunKey)}&run_result[]=CASE${encodeURIComponent(caseKey)}`;
+        if (comments) {
+            endpoint += `&comments=${encodeURIComponent(comments)}`;
+        }
+        if (screenshotPath && fs.existsSync(screenshotPath)) {
+            const stat = fs.statSync(screenshotPath);
+            if (stat.size <= 2 * 1024 * 1024) {
+                return this.multipartRequest(endpoint, screenshotPath);
+            }
+        }
+        return this.request("POST", endpoint);
+    }
+}
+exports.QATouchClient = QATouchClient;
+function statusIdToName(id) {
+    switch (id) {
+        case 1: return "passed";
+        case 3: return "blocked";
+        case 4: return "retest";
+        case 5: return "failed";
+        case 6: return "not-applicable";
+        case 7: return "in-progress";
+        default: return "untested";
+    }
+}

package/dist/reporter.d.ts

@@ -0,0 +1,20 @@
+export interface TestCompleteQATouchReporterOptions {
+    domain: string;
+    apiToken: string;
+    projectKey: string;
+    assignTo: string;
+    resultsFile: string;
+    testsuiteId?: string;
+    milestoneName?: string;
+    milestoneKey?: string;
+    createCases?: boolean;
+    tag?: string;
+}
+export declare class TestCompleteQATouchReporter {
+    private opts;
+    private client;
+    constructor(options: TestCompleteQATouchReporterOptions);
+    run(): Promise<void>;
+    private resolveMilestone;
+    private resolveModules;
+}

package/dist/reporter.js

@@ -0,0 +1,260 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestCompleteQATouchReporter = void 0;
+const fs = __importStar(require("fs"));
+const qatouch_client_1 = require("./qatouch-client");
+function normalizeTitle(t) { return t.replace(/[^a-z0-9\s]/gi, " ").replace(/\s+/g, " ").trim().toLowerCase(); }
+function extractCaseKey(i) { return i.case_key || i.caseKey || i.key || i.api_key || i.apiKey || i.id || null; }
+function extractRunKey(i) { return i.testrun_id || i.key || i.testRunKey || i.testrunkey || i.test_run || null; }
+function extractMilestoneKey(i) { return i.milestone_key || i.key || i.milestoneKey || i.id || null; }
+function extractModuleKey(i) { return i.section_key || i.module_key || i.key || i.sectionKey || i.api_key || i.apiKey || i.id || null; }
+function extractModuleName(i) { return i.section_name || i.module_name || i.name || i.title || i.sectionName || null; }
+function statusToId(s) { switch (s) {
+    case "passed": return 1;
+    case "failed": return 5;
+    case "blocked": return 3;
+    default: return 2;
+} }
+function buildStepsTemplate(title) {
+    const steps = {
+        "0": { steps: `Open the application for: ${title}.`, expected_result: "Application is in the expected initial state." },
+        "1": { steps: `Execute the TestComplete automated scenario: ${title}.`, expected_result: "All keyword/scripted interactions complete without errors." },
+        "2": { steps: `Validate checkpoints for: ${title}.`, expected_result: "All TestComplete checkpoints pass." },
+    };
+    return encodeURIComponent(JSON.stringify(steps));
+}
+function parseJUnitXml(xml) {
+    const tests = [];
+    const suiteRe = /<testsuite\s([^>]*)>([\s\S]*?)<\/testsuite>/gi;
+    for (const sm of xml.matchAll(suiteRe)) {
+        const sa = sm[1] || "";
+        const si = sm[2] || "";
+        const snm = sa.match(/name="([^"]*)"/i);
+        const suiteName = snm ? snm[1] : "Default";
+        const caseRe = /<testcase\s([^>]*)(?:\/>|>([\s\S]*?)<\/testcase>)/gi;
+        for (const cm of si.matchAll(caseRe)) {
+            const ca = cm[1] || "";
+            const ci = cm[2] || "";
+            const get = (a) => { const m = ca.match(new RegExp(`${a}="([^"]*)"`, "i")); return m ? m[1] : ""; };
+            const title = get("name");
+            if (!title)
+                continue;
+            let status = "passed";
+            let errorMessage;
+            if (/<failure/i.test(ci) || /<error/i.test(ci)) {
+                status = "failed";
+                const mm = ci.match(/<(?:failure|error)[^>]*message="([^"]*)"/i);
+                if (mm)
+                    errorMessage = mm[1].slice(0, 2000);
+                else {
+                    const tm = ci.match(/<(?:failure|error)[^>]*>([\s\S]*?)<\/(?:failure|error)>/i);
+                    if (tm)
+                        errorMessage = tm[1].replace(/<[^>]+>/g, "").trim().slice(0, 2000);
+                }
+            }
+            else if (/<skipped/i.test(ci))
+                status = "blocked";
+            tests.push({ fullName: `${suiteName}.${title}`, title, normalizedTitle: normalizeTitle(title), suiteName, status, errorMessage });
+        }
+    }
+    return tests;
+}
+class TestCompleteQATouchReporter {
+    constructor(options) {
+        this.opts = {
+            domain: options.domain, apiToken: options.apiToken, projectKey: options.projectKey,
+            assignTo: options.assignTo, resultsFile: options.resultsFile,
+            testsuiteId: options.testsuiteId, milestoneName: options.milestoneName || "TestComplete Automation",
+            milestoneKey: options.milestoneKey, createCases: options.createCases !== false,
+            tag: options.tag || "testcomplete",
+        };
+        this.client = new qatouch_client_1.QATouchClient({ domain: this.opts.domain, apiToken: this.opts.apiToken, projectKey: this.opts.projectKey });
+    }
+    async run() {
+        const tests = parseJUnitXml(fs.readFileSync(this.opts.resultsFile, "utf-8"));
+        if (tests.length === 0) {
+            console.warn("[testcomplete-qatouch] No test cases found.");
+            return;
+        }
+        const suiteMap = new Map();
+        for (const t of tests) {
+            const l = suiteMap.get(t.suiteName) || [];
+            l.push(t);
+            suiteMap.set(t.suiteName, l);
+        }
+        const mkByS = await this.resolveModules([...suiteMap.keys()]);
+        const caseMap = new Map();
+        for (const mk of new Set(mkByS.values())) {
+            for (const item of await this.client.getTestCases(mk)) {
+                const t = (item.title || item.case_title || "").trim();
+                const k = extractCaseKey(item);
+                if (t && k)
+                    caseMap.set(normalizeTitle(t), k);
+            }
+        }
+        if (this.opts.createCases) {
+            for (const [sn, st] of suiteMap) {
+                const mk = mkByS.get(sn);
+                if (!mk)
+                    continue;
+                for (const test of st) {
+                    if (caseMap.has(test.normalizedTitle))
+                        continue;
+                    await this.client.createTestCase(mk, test.title, `Automated TestComplete scenario: ${test.title}`, test.fullName, "The TestComplete project is configured and the AUT is running.", buildStepsTemplate(test.title));
+                    for (const item of await this.client.getTestCases(mk)) {
+                        const t = (item.title || item.case_title || "").trim();
+                        const k = extractCaseKey(item);
+                        if (t && k)
+                            caseMap.set(normalizeTitle(t), k);
+                    }
+                }
+            }
+        }
+        const milestoneKey = await this.resolveMilestone();
+        if (!milestoneKey)
+            throw new Error("[testcomplete-qatouch] Unable to resolve milestone key.");
+        const bulk = [];
+        const detailed = [];
+        const caseKeys = [];
+        for (const test of tests) {
+            const ck = caseMap.get(test.normalizedTitle);
+            if (!ck) {
+                console.warn(`[testcomplete-qatouch] Unmapped: ${test.title}`);
+                continue;
+            }
+            caseKeys.push(ck);
+            if (test.status === "failed" && test.errorMessage)
+                detailed.push({ caseKey: ck, test });
+            else
+                bulk.push({ case: ck, status: statusToId(test.status) });
+        }
+        if (caseKeys.length === 0) {
+            console.warn("[testcomplete-qatouch] No mapped cases.");
+            return;
+        }
+        const rp = await this.client.createTestRun(milestoneKey, `TestComplete Run ${new Date().toISOString()}`, this.opts.assignTo, [...new Set(caseKeys)], this.opts.tag);
+        const trk = extractRunKey(rp);
+        if (!trk)
+            throw new Error("[testcomplete-qatouch] Test run returned no key.");
+        for (const { caseKey, test } of detailed) {
+            try {
+                await this.client.addResultWithComment(trk, caseKey, statusToId(test.status), test.errorMessage);
+            }
+            catch (e) {
+                console.error(`[testcomplete-qatouch] ${e.message}`);
+                bulk.push({ case: caseKey, status: statusToId(test.status) });
+            }
+        }
+        if (bulk.length > 0) {
+            try {
+                const r = await this.client.updateResults(trk, bulk);
+                if (r?.error)
+                    throw new Error(r.error);
+            }
+            catch {
+                for (const item of bulk) {
+                    try {
+                        await this.client.addResultWithComment(trk, item.case, item.status);
+                    }
+                    catch (e) {
+                        console.error(`[testcomplete-qatouch] ${e.message}`);
+                    }
+                }
+            }
+        }
+        console.log(`[testcomplete-qatouch] Uploaded ${caseKeys.length} result(s) to run ${trk}.`);
+    }
+    async resolveMilestone() {
+        if (this.opts.milestoneKey)
+            return this.opts.milestoneKey;
+        const name = this.opts.milestoneName;
+        const find = (list) => list.find((m) => (m.milestone_name || m.name || m.title || m.milestone || "") === name);
+        let ms = await this.client.getMilestones();
+        if (find(ms))
+            return extractMilestoneKey(find(ms));
+        await this.client.createMilestone(name);
+        ms = await this.client.getMilestones();
+        return find(ms) ? extractMilestoneKey(find(ms)) : null;
+    }
+    async resolveModules(suiteNames) {
+        const mm = new Map();
+        if (this.opts.testsuiteId) {
+            for (const n of suiteNames)
+                mm.set(n, this.opts.testsuiteId);
+            return mm;
+        }
+        let existing = await this.client.getModules();
+        const byName = new Map();
+        for (const m of existing) {
+            const n = extractModuleName(m);
+            const k = extractModuleKey(m);
+            if (n && k)
+                byName.set(n.toLowerCase().trim(), k);
+        }
+        for (const sn of suiteNames) {
+            const norm = sn.toLowerCase().trim();
+            if (byName.has(norm)) {
+                mm.set(sn, byName.get(norm));
+                continue;
+            }
+            let ck = null;
+            try {
+                ck = extractModuleKey(await this.client.createModule(sn));
+            }
+            catch (e) {
+                console.warn(`[testcomplete-qatouch] createModule: ${e.message}`);
+            }
+            if (!ck) {
+                existing = await this.client.getModules();
+                for (const m of existing) {
+                    const n = extractModuleName(m);
+                    const k = extractModuleKey(m);
+                    if (n && k)
+                        byName.set(n.toLowerCase().trim(), k);
+                }
+                ck = byName.get(norm) || null;
+            }
+            if (ck) {
+                mm.set(sn, ck);
+                byName.set(norm, ck);
+            }
+            else
+                console.error(`[testcomplete-qatouch] Failed to resolve module: ${sn}`);
+        }
+        return mm;
+    }
+}
+exports.TestCompleteQATouchReporter = TestCompleteQATouchReporter;

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "testcomplete-qatouch",
+  "version": "1.0.0",
+  "description": "QA Touch reporter for TestComplete (SmartBear) — auto-creates modules, test cases and test runs from JUnit XML exports.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist"],
+  "scripts": { "build": "tsc", "prepare": "npm run build", "prepublishOnly": "npm run build" },
+  "keywords": ["testcomplete","smartbear","junit","qatouch","reporter","test-management","qa"],
+  "author": "UjjwalaMeena",
+  "license": "ISC",
+  "repository": { "type": "git", "url": "git+https://github.com/ujjwala91/testcomplete-qatouch.git" },
+  "homepage": "https://github.com/ujjwala91/testcomplete-qatouch#readme",
+  "bugs": { "url": "https://github.com/ujjwala91/testcomplete-qatouch/issues" },
+  "devDependencies": { "@types/node": "^20.0.0", "typescript": "^5.7.0" }
+}