@testmo/testmo-link 1.0.0-beta.0

package/dist/linking/patternMatcher.js

@@ -0,0 +1,173 @@
+"use strict";
+/*
+ * Copyright (c) Testmo GmbH (Berlin, Germany)
+ * All rights reserved.
+ * contact@testmo.com - www.testmo.com
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PatternMatcher = void 0;
+const logger_1 = require("../lib/logger");
+const errors_1 = require("../lib/errors");
+const retry_1 = require("../lib/retry");
+/**
+ * Matches test names to repository case names using configurable regex rules.
+ */
+class PatternMatcher {
+    constructor(rules) {
+        this.cases = [];
+        this.casesByNormalizedName = new Map();
+        this.compiledRules = [];
+        this.folderIdByNormalizedName = new Map();
+        this.loaded = false;
+        for (const rule of rules) {
+            if (rule.type !== 'name_match') {
+                logger_1.logger.warn(`Unknown pattern rule type "${rule.type}" — skipping`);
+                continue;
+            }
+            // Validate regex compiles
+            try {
+                // Case-insensitive matching
+                this.compiledRules.push({
+                    source: rule.pattern,
+                    regex: new RegExp(rule.pattern, 'i'),
+                    folder: typeof rule.folder === 'string' ? rule.folder : undefined,
+                });
+            }
+            catch (e) {
+                throw new errors_1.PatternError(rule.pattern, e.message);
+            }
+        }
+    }
+    /**
+     * Fetch all repository cases (id, name, folder_id) and, when any rule
+     * uses folder scoping, fetch folder name→id mappings too.
+     */
+    async loadCases(client, projectId) {
+        var _a, _b;
+        if (this.loaded)
+            return;
+        let page = 1;
+        const perPage = 1000;
+        while (true) {
+            const result = await (0, retry_1.withRetry)(() => client.callApi('/api/v1/projects/{project_id}/cases/names', 'GET', { project_id: projectId }, { page, per_page: perPage }, {}, {}, null, ['bearerAuth'], ['application/json'], ['application/json'], Object, null));
+            const data = result.data;
+            const pageCases = (_a = data === null || data === void 0 ? void 0 : data.result) !== null && _a !== void 0 ? _a : [];
+            for (const c of pageCases) {
+                if (c.id && c.name) {
+                    const record = {
+                        id: c.id,
+                        name: c.name,
+                        folderId: (_b = c.folder_id) !== null && _b !== void 0 ? _b : null,
+                    };
+                    this.cases.push(record);
+                    const key = this.normalize(c.name);
+                    const existing = this.casesByNormalizedName.get(key);
+                    if (existing) {
+                        existing.push(record);
+                    }
+                    else {
+                        this.casesByNormalizedName.set(key, [record]);
+                    }
+                }
+            }
+            if (!(data === null || data === void 0 ? void 0 : data.next_page))
+                break;
+            page = data.next_page;
+        }
+        // Load folder name→id mappings when at least one rule uses folder scoping
+        const needsFolders = this.compiledRules.some(r => r.folder !== undefined);
+        if (needsFolders) {
+            await this.loadFolders(client, projectId);
+        }
+        this.loaded = true;
+        logger_1.logger.debug(`Loaded ${this.cases.length} repository case(s) for pattern matching`);
+    }
+    async loadFolders(client, projectId) {
+        var _a;
+        let page = 1;
+        const perPage = 100;
+        while (true) {
+            const result = await (0, retry_1.withRetry)(() => client.callApi('/api/v1/projects/{project_id}/folders', 'GET', { project_id: projectId }, { page, per_page: perPage }, {}, {}, null, ['bearerAuth'], ['application/json'], ['application/json'], Object, null));
+            const data = result.data;
+            const folders = (_a = data === null || data === void 0 ? void 0 : data.result) !== null && _a !== void 0 ? _a : [];
+            for (const f of folders) {
+                if (f.id && f.name) {
+                    this.folderIdByNormalizedName.set(this.normalize(f.name), f.id);
+                }
+            }
+            if (!(data === null || data === void 0 ? void 0 : data.next_page))
+                break;
+            page = data.next_page;
+        }
+        logger_1.logger.debug(`Loaded ${this.folderIdByNormalizedName.size} folder(s) for pattern matching`);
+    }
+    /**
+     * Match a test name to a repository case.
+     *
+     * When linkedCaseIds is provided, already-linked cases are filtered out
+     * before the ambiguity check so that duplicate case names across folders
+     * don't prevent unlinked cases from being matched.
+     *
+     * Returns the case ID if exactly one unlinked match is found; undefined otherwise.
+     */
+    match(testName, linkedCaseIds) {
+        if (this.cases.length === 0)
+            return undefined;
+        const matchedCases = this.findMatchingCases(testName);
+        if (matchedCases.length === 0)
+            return undefined;
+        // Filter out cases that are already linked elsewhere in this run
+        const candidates = linkedCaseIds && linkedCaseIds.size > 0
+            ? matchedCases.filter(c => !linkedCaseIds.has(c.id))
+            : matchedCases;
+        if (candidates.length === 1) {
+            return candidates[0].id;
+        }
+        // Ambiguous — warn and skip
+        if (candidates.length > 1) {
+            logger_1.logger.warn(`Ambiguous pattern match for "${testName}": ` +
+                `${candidates.length} cases matched (IDs: ${candidates.map(c => c.id).join(', ')}) — skipping`);
+        }
+        return undefined;
+    }
+    findMatchingCases(testName) {
+        var _a, _b;
+        // If rules are configured, apply them: regex transforms test name → search term
+        if (this.compiledRules.length > 0) {
+            for (const { regex, folder } of this.compiledRules) {
+                const m = testName.match(regex);
+                if (!m)
+                    continue;
+                // Use first captured group as search term, or full match if no groups
+                const searchTerm = m[1] !== undefined ? m[1] : m[0];
+                const normalized = this.normalize(searchTerm);
+                let hits = (_a = this.casesByNormalizedName.get(normalized)) !== null && _a !== void 0 ? _a : [];
+                // Apply folder scoping when the rule specifies a folder
+                if (folder !== undefined && hits.length > 0) {
+                    const folderId = this.folderIdByNormalizedName.get(this.normalize(folder));
+                    if (folderId !== undefined) {
+                        hits = hits.filter(c => c.folderId === folderId);
+                    }
+                    else {
+                        logger_1.logger.warn(`Pattern rule specifies unknown folder "${folder}" — ` +
+                            `folder filter skipped for "${testName}"`);
+                    }
+                }
+                if (hits.length > 0)
+                    return hits;
+            }
+            return [];
+        }
+        // No rules — direct case-insensitive name match
+        const normalized = this.normalize(testName);
+        return (_b = this.casesByNormalizedName.get(normalized)) !== null && _b !== void 0 ? _b : [];
+    }
+    /** Normalize for comparison: lowercase, collapse whitespace/underscores/dashes. */
+    normalize(s) {
+        return s.toLowerCase().replace(/[\s_-]+/g, ' ').trim();
+    }
+    getCaseCount() {
+        return this.cases.length;
+    }
+}
+exports.PatternMatcher = PatternMatcher;

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@testmo/testmo-link",
+  "version": "1.0.0-beta.0",
+  "description": "Testmo automation linking tool — link automation test results to repository test cases",
+  "author": "Testmo GmbH",
+  "homepage": "https://www.testmo.com/",
+  "main": "dist/index.js",
+  "bin": {
+    "testmo-link": "dist/index.js"
+  },
+  "files": [
+    "dist/**/*.js"
+  ],
+  "scripts": {
+    "lint": "npm run compile && npx eslint \"src/**/*.ts\"",
+    "compile": "tsc -p tsconfig.json",
+    "test": "TS_NODE_PROJECT=tsconfig.mocha.json node_modules/mocha/bin/mocha.js",
+    "test-ci": "TS_NODE_PROJECT=tsconfig.mocha.json node_modules/mocha/bin/mocha.js --reporter node_modules/mocha-junit-reporter --reporter-options jenkinsMode=1,mochaFile=results/results.xml",
+    "clean": "rm -rf dist/ && rm -f testmo-link*.tgz",
+    "prepack": "npm run clean && npm run compile"
+  },
+  "devDependencies": {
+    "@types/chai": "^5.0.1",
+    "@types/chai-as-promised": "^7.1.8",
+    "@types/js-yaml": "^4.0.9",
+    "@types/lodash": "^4.17.14",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^22.10.7",
+    "@types/sinon": "^17.0.3",
+    "@types/validator": "^13.12.2",
+    "@typescript-eslint/eslint-plugin": "^8.20.0",
+    "@typescript-eslint/parser": "^8.20.0",
+    "chai": "^4.5.0",
+    "chai-as-promised": "^7.1.2",
+    "eslint": "^8.57.1",
+    "mocha": "^11.0.1",
+    "mocha-junit-reporter": "^2.2.1",
+    "sinon": "^19.0.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.7.3"
+  },
+  "dependencies": {
+    "@testmo/testmo-api": "2.7.0-beta.0",
+    "chalk": "^4.1.2",
+    "commander": "^8.3.0",
+    "glob": "^11.0.1",
+    "js-yaml": "^4.1.0",
+    "lodash": "^4.17.21",
+    "validator": "^13.11.0"
+  }
+}