@elisra-devops/docgen-data-provider 1.79.0 → 1.81.0

package/bin/models/mewp-reporting.d.ts

@@ -62,17 +62,18 @@ export interface MewpL3L4Link {
     title: string;
     level: 'L3' | 'L4';
 }
-export interface MewpCoverageBugCell {
-    id: number | '';
-    title: string;
-    responsibility: string;
-}
-export interface MewpCoverageL3L4Cell {
+export interface MewpL3L4Pair {
     l3Id: string;
     l3Title: string;
     l4Id: string;
     l4Title: string;
 }
+export interface MewpCoverageBugCell {
+    id: number | '';
+    title: string;
+    responsibility: string;
+}
+export type MewpCoverageL3L4Cell = MewpL3L4Pair;
 export interface MewpCoverageRow {
     'L2 REQ ID': string;
     'L2 REQ Title': string;

package/bin/modules/ResultDataProvider.d.ts

@@ -118,6 +118,8 @@ export default class ResultDataProvider {
     private fetchMewpL2Requirements;
     private isMewpL2AreaPath;
     private collapseMewpRequirementFamilies;
+    private buildMewpL2ToLinkedL1BaseKeys;
+    private buildMewpExternalJoinKeysByL2Requirement;
     private buildRequirementFamilyMap;
     private buildLinkedRequirementsByTestCase;
     private resolveMewpRequirementScopeKeysFromQuery;

package/bin/modules/ResultDataProvider.js

@@ -304,6 +304,7 @@ class ResultDataProvider {
             const linkedRequirementsByTestCase = await this.buildLinkedRequirementsByTestCase(allRequirements, testData, projectName);
             const scopedRequirementKeys = await this.resolveMewpRequirementScopeKeysFromQuery(linkedQueryRequest, allRequirements, linkedRequirementsByTestCase);
             const requirements = this.collapseMewpRequirementFamilies(allRequirements, (scopedRequirementKeys === null || scopedRequirementKeys === void 0 ? void 0 : scopedRequirementKeys.size) ? scopedRequirementKeys : undefined);
+            const l2ToLinkedL1BaseKeys = await this.buildMewpL2ToLinkedL1BaseKeys(allRequirements, projectName, testData);
             const requirementSapWbsByBaseKey = this.buildRequirementSapWbsByBaseKey(allRequirements);
             const externalBugsByTestCase = await this.loadExternalBugsByTestCase(options === null || options === void 0 ? void 0 : options.externalBugsFile);
             const externalL3L4ByBaseKey = await this.loadExternalL3L4ByBaseKey(options === null || options === void 0 ? void 0 : options.externalL3L4File, requirementSapWbsByBaseKey);
@@ -333,6 +334,7 @@ class ResultDataProvider {
             if (requirements.length === 0) {
                 return Object.assign(Object.assign({}, defaultPayload), { sheetName: this.buildMewpCoverageSheetName(planName, testPlanId) });
             }
+            const externalJoinKeysByL2 = this.buildMewpExternalJoinKeysByL2Requirement(requirements, l2ToLinkedL1BaseKeys);
             const requirementIndex = new Map();
             const observedTestCaseIdsByRequirement = new Map();
             const requirementKeys = new Set();
@@ -382,8 +384,15 @@ class ResultDataProvider {
                 this.accumulateRequirementCountsFromActionResults(fallbackActionResults, testCaseId, requirementKeys, requirementIndex, observedTestCaseIdsByRequirement);
             }
             const requirementBaseKeys = new Set(requirements.map((item) => String((item === null || item === void 0 ? void 0 : item.baseKey) || '').trim()).filter((item) => !!item));
+            const externalJoinKeyUniverse = new Set();
+            for (const keySet of externalJoinKeysByL2.values()) {
+                for (const key of keySet) {
+                    if (key)
+                        externalJoinKeyUniverse.add(key);
+                }
+            }
             const externalL3L4BaseKeys = new Set([...externalL3L4ByBaseKey.keys()]);
-            const externalL3L4OverlapKeys = [...externalL3L4BaseKeys].filter((key) => requirementBaseKeys.has(key));
+            const externalL3L4OverlapKeys = [...externalL3L4BaseKeys].filter((key) => externalJoinKeyUniverse.has(key));
             const failedRequirementBaseKeys = new Set();
             const failedTestCaseIds = new Set();
             for (const [requirementBaseKey, byTestCase] of requirementIndex.entries()) {
@@ -404,9 +413,10 @@ class ResultDataProvider {
                         externalBugBaseKeys.add(key);
                 }
             }
-            const externalBugRequirementOverlap = [...externalBugBaseKeys].filter((key) => requirementBaseKeys.has(key));
-            const externalBugFailedRequirementOverlap = [...externalBugBaseKeys].filter((key) => failedRequirementBaseKeys.has(key));
+            const externalBugRequirementOverlap = [...externalBugBaseKeys].filter((key) => externalJoinKeyUniverse.has(key));
+            const externalBugFailedRequirementOverlap = [...externalBugBaseKeys].filter((key) => externalJoinKeyUniverse.has(key));
             logger_1.default.info(`MEWP coverage join diagnostics: requirementBaseKeys=${requirementBaseKeys.size} ` +
+                `externalJoinKeys=${externalJoinKeyUniverse.size} ` +
                 `failedRequirementBaseKeys=${failedRequirementBaseKeys.size} failedTestCases=${failedTestCaseIds.size}; ` +
                 `externalL3L4BaseKeys=${externalL3L4BaseKeys.size} externalL3L4Overlap=${externalL3L4OverlapKeys.length}; ` +
                 `externalBugTestCases=${externalBugTestCaseIds.size} externalBugFailedTestCaseOverlap=${externalBugFailedTestCaseOverlap.length}; ` +
@@ -414,21 +424,25 @@ class ResultDataProvider {
                 `externalBugFailedRequirementOverlap=${externalBugFailedRequirementOverlap.length}`);
             if (externalL3L4BaseKeys.size > 0 && externalL3L4OverlapKeys.length === 0) {
                 const sampleReq = [...requirementBaseKeys].slice(0, 5);
+                const sampleJoin = [...externalJoinKeyUniverse].slice(0, 5);
                 const sampleExt = [...externalL3L4BaseKeys].slice(0, 5);
                 logger_1.default.warn(`MEWP coverage join diagnostics: no L3/L4 key overlap found. ` +
-                    `sampleRequirementKeys=${sampleReq.join(', ')} sampleExternalL3L4Keys=${sampleExt.join(', ')}`);
+                    `sampleRequirementKeys=${sampleReq.join(', ')} sampleJoinKeys=${sampleJoin.join(', ')} ` +
+                    `sampleExternalL3L4Keys=${sampleExt.join(', ')}`);
             }
             if (externalBugBaseKeys.size > 0 && externalBugRequirementOverlap.length === 0) {
                 const sampleReq = [...requirementBaseKeys].slice(0, 5);
+                const sampleJoin = [...externalJoinKeyUniverse].slice(0, 5);
                 const sampleExt = [...externalBugBaseKeys].slice(0, 5);
                 logger_1.default.warn(`MEWP coverage join diagnostics: no bug requirement-key overlap found. ` +
-                    `sampleRequirementKeys=${sampleReq.join(', ')} sampleExternalBugKeys=${sampleExt.join(', ')}`);
+                    `sampleRequirementKeys=${sampleReq.join(', ')} sampleJoinKeys=${sampleJoin.join(', ')} ` +
+                    `sampleExternalBugKeys=${sampleExt.join(', ')}`);
             }
             if (externalBugTestCaseIds.size > 0 && externalBugFailedTestCaseOverlap.length === 0) {
                 logger_1.default.warn(`MEWP coverage join diagnostics: no overlap between external bug test cases and failed test cases. ` +
                     `Bug rows remain empty because bugs are shown only for failed L2s.`);
             }
-            const rows = this.buildMewpCoverageRows(requirements, requirementIndex, observedTestCaseIdsByRequirement, linkedRequirementsByTestCase, externalL3L4ByBaseKey, externalBugsByTestCase);
+            const rows = this.buildMewpCoverageRows(requirements, requirementIndex, observedTestCaseIdsByRequirement, linkedRequirementsByTestCase, externalL3L4ByBaseKey, externalBugsByTestCase, externalJoinKeysByL2);
             const coverageRowStats = rows.reduce((acc, row) => {
                 const hasBug = Number((row === null || row === void 0 ? void 0 : row['Bug ID']) || 0) > 0;
                 const hasL3 = String((row === null || row === void 0 ? void 0 : row['L3 REQ ID']) || '').trim() !== '';
@@ -493,12 +507,24 @@ class ResultDataProvider {
                 }
             }
             const validL2BaseKeys = new Set([...requirementFamilies.keys()]);
+            const diagnostics = {
+                totalTestCases: 0,
+                totalParsedSteps: 0,
+                totalStepsWithMentions: 0,
+                totalMentionedCustomerIds: 0,
+                testCasesWithoutMentionedCustomerIds: 0,
+                failingRows: 0,
+            };
             for (const testCaseId of [...allTestCaseIds].sort((a, b) => a - b)) {
+                diagnostics.totalTestCases += 1;
                 const stepsXml = stepsXmlByTestCase.get(testCaseId) || '';
                 const parsedSteps = stepsXml && String(stepsXml).trim() !== ''
                     ? await this.testStepParserHelper.parseTestSteps(stepsXml, new Map())
                     : [];
+                const executableSteps = parsedSteps.filter((step) => !(step === null || step === void 0 ? void 0 : step.isSharedStepTitle));
+                diagnostics.totalParsedSteps += executableSteps.length;
                 const mentionEntries = this.extractRequirementMentionsFromExpectedSteps(parsedSteps, true);
+                diagnostics.totalStepsWithMentions += mentionEntries.length;
                 const mentionedL2Only = new Set();
                 const mentionedCodeFirstStep = new Map();
                 const mentionedBaseFirstStep = new Map();
@@ -521,6 +547,10 @@ class ResultDataProvider {
                         }
                     }
                 }
+                diagnostics.totalMentionedCustomerIds += mentionedL2Only.size;
+                if (mentionedL2Only.size === 0) {
+                    diagnostics.testCasesWithoutMentionedCustomerIds += 1;
+                }
                 const mentionedBaseKeys = new Set([...mentionedL2Only].map((code) => this.toRequirementKey(code)).filter((code) => !!code));
                 const expectedFamilyCodes = new Set();
                 for (const baseKey of mentionedBaseKeys) {
@@ -597,6 +627,14 @@ class ResultDataProvider {
                     .join('; ');
                 const linkedButNotMentioned = sortedExtraLinked.join('; ');
                 const validationStatus = mentionedButNotLinked || linkedButNotMentioned ? 'Fail' : 'Pass';
+                if (validationStatus === 'Fail')
+                    diagnostics.failingRows += 1;
+                logger_1.default.debug(`MEWP internal validation parse diagnostics: ` +
+                    `testCaseId=${testCaseId} parsedSteps=${executableSteps.length} ` +
+                    `stepsWithMentions=${mentionEntries.length} customerIdsFound=${mentionedL2Only.size} ` +
+                    `linkedRequirements=${linkedFullCodes.size} mentionedButNotLinked=${sortedMissingMentioned.length + sortedMissingFamily.length} ` +
+                    `linkedButNotMentioned=${sortedExtraLinked.length} status=${validationStatus} ` +
+                    `customerIdSample='${[...mentionedL2Only].slice(0, 5).join(', ')}'`);
                 rows.push({
                     'Test Case ID': testCaseId,
                     'Test Case Title': String(testCaseTitleMap.get(testCaseId) || '').trim(),
@@ -605,6 +643,11 @@ class ResultDataProvider {
                     'Validation Status': validationStatus,
                 });
             }
+            logger_1.default.info(`MEWP internal validation summary: testCases=${diagnostics.totalTestCases} ` +
+                `parsedSteps=${diagnostics.totalParsedSteps} stepsWithMentions=${diagnostics.totalStepsWithMentions} ` +
+                `totalCustomerIdsFound=${diagnostics.totalMentionedCustomerIds} ` +
+                `testCasesWithoutCustomerIds=${diagnostics.testCasesWithoutMentionedCustomerIds} ` +
+                `failingRows=${diagnostics.failingRows}`);
             return {
                 sheetName: this.buildInternalValidationSheetName(planName, testPlanId),
                 columnOrder: [...ResultDataProvider.INTERNAL_VALIDATION_COLUMNS],
@@ -718,30 +761,43 @@ class ResultDataProvider {
     createEmptyMewpCoverageL3L4Cell() {
         return { l3Id: '', l3Title: '', l4Id: '', l4Title: '' };
     }
-    buildMewpCoverageL3L4Rows(links) {
-        const sorted = [...(links || [])].sort((a, b) => {
-            if (a.level !== b.level)
-                return a.level === 'L3' ? -1 : 1;
-            return String(a.id || '').localeCompare(String(b.id || ''));
-        });
-        const rows = [];
-        for (const item of sorted) {
-            const isL3 = item.level === 'L3';
-            rows.push({
-                l3Id: isL3 ? String((item === null || item === void 0 ? void 0 : item.id) || '').trim() : '',
-                l3Title: isL3 ? String((item === null || item === void 0 ? void 0 : item.title) || '').trim() : '',
-                l4Id: isL3 ? '' : String((item === null || item === void 0 ? void 0 : item.id) || '').trim(),
-                l4Title: isL3 ? '' : String((item === null || item === void 0 ? void 0 : item.title) || '').trim(),
+    buildMewpCoverageL3L4Rows(pairs) {
+        const deduped = new Map();
+        for (const pair of pairs || []) {
+            const l3Id = String((pair === null || pair === void 0 ? void 0 : pair.l3Id) || '').trim();
+            const l3Title = String((pair === null || pair === void 0 ? void 0 : pair.l3Title) || '').trim();
+            const l4Id = String((pair === null || pair === void 0 ? void 0 : pair.l4Id) || '').trim();
+            const l4Title = String((pair === null || pair === void 0 ? void 0 : pair.l4Title) || '').trim();
+            if (!l3Id && !l4Id)
+                continue;
+            const key = `${l3Id}|${l4Id}`;
+            const existing = deduped.get(key);
+            if (!existing) {
+                deduped.set(key, { l3Id, l3Title, l4Id, l4Title });
+                continue;
+            }
+            deduped.set(key, {
+                l3Id: existing.l3Id || l3Id,
+                l3Title: existing.l3Title || l3Title,
+                l4Id: existing.l4Id || l4Id,
+                l4Title: existing.l4Title || l4Title,
             });
         }
-        return rows;
+        return [...deduped.values()].sort((a, b) => {
+            const l3Compare = String((a === null || a === void 0 ? void 0 : a.l3Id) || '').localeCompare(String((b === null || b === void 0 ? void 0 : b.l3Id) || ''));
+            if (l3Compare !== 0)
+                return l3Compare;
+            return String((a === null || a === void 0 ? void 0 : a.l4Id) || '').localeCompare(String((b === null || b === void 0 ? void 0 : b.l4Id) || ''));
+        });
     }
-    buildMewpCoverageRows(requirements, requirementIndex, observedTestCaseIdsByRequirement, linkedRequirementsByTestCase, l3l4ByBaseKey, externalBugsByTestCase) {
+    buildMewpCoverageRows(requirements, requirementIndex, observedTestCaseIdsByRequirement, linkedRequirementsByTestCase, l3l4ByBaseKey, externalBugsByTestCase, externalJoinKeysByL2) {
         var _a;
         const rows = [];
         const linkedByRequirement = this.invertBaseRequirementLinks(linkedRequirementsByTestCase);
+        const joinKeysByRequirement = externalJoinKeysByL2 || new Map();
         for (const requirement of requirements) {
             const key = String((requirement === null || requirement === void 0 ? void 0 : requirement.baseKey) || this.toRequirementKey(requirement.requirementId) || '').trim();
+            const externalJoinKeys = joinKeysByRequirement.get(key) || new Set([key]);
             const linkedTestCaseIds = ((requirement === null || requirement === void 0 ? void 0 : requirement.linkedTestCaseIds) || []).filter((id) => Number.isFinite(id) && Number(id) > 0);
             const linkedByTestCase = key ? Array.from(linkedByRequirement.get(key) || []) : [];
             const observedTestCaseIds = key
@@ -763,7 +819,7 @@ class ResultDataProvider {
                     const externalBugs = externalBugsByTestCase.get(testCaseId) || [];
                     for (const bug of externalBugs) {
                         const bugBaseKey = String((bug === null || bug === void 0 ? void 0 : bug.requirementBaseKey) || '').trim();
-                        if (bugBaseKey && bugBaseKey !== key)
+                        if (bugBaseKey && !externalJoinKeys.has(bugBaseKey))
                             continue;
                         const bugId = Number((bug === null || bug === void 0 ? void 0 : bug.id) || 0);
                         if (!Number.isFinite(bugId) || bugId <= 0)
@@ -781,20 +837,16 @@ class ResultDataProvider {
             const bugsForRows = runStatus === 'Fail'
                 ? Array.from(aggregatedBugs.values()).sort((a, b) => a.id - b.id)
                 : [];
-            const l3l4ForRows = [...(l3l4ByBaseKey.get(key) || [])];
-            const bugRows = bugsForRows.length > 0
-                ? bugsForRows
-                : [];
+            const l3l4ForRows = [...externalJoinKeys].flatMap((joinKey) => l3l4ByBaseKey.get(joinKey) || []);
+            const bugRows = bugsForRows.map((bug) => ({
+                id: Number.isFinite(Number(bug === null || bug === void 0 ? void 0 : bug.id)) && Number(bug === null || bug === void 0 ? void 0 : bug.id) > 0 ? Number(bug === null || bug === void 0 ? void 0 : bug.id) : '',
+                title: String((bug === null || bug === void 0 ? void 0 : bug.title) || '').trim(),
+                responsibility: String((bug === null || bug === void 0 ? void 0 : bug.responsibility) || '').trim(),
+            }));
             const l3l4Rows = this.buildMewpCoverageL3L4Rows(l3l4ForRows);
-            if (bugRows.length === 0 && l3l4Rows.length === 0) {
-                rows.push(this.createMewpCoverageRow(requirement, runStatus, this.createEmptyMewpCoverageBugCell(), this.createEmptyMewpCoverageL3L4Cell()));
-                continue;
-            }
-            for (const bug of bugRows) {
-                rows.push(this.createMewpCoverageRow(requirement, runStatus, bug, this.createEmptyMewpCoverageL3L4Cell()));
-            }
-            for (const linkedL3L4 of l3l4Rows) {
-                rows.push(this.createMewpCoverageRow(requirement, runStatus, this.createEmptyMewpCoverageBugCell(), linkedL3L4));
+            const rowCount = Math.max(bugRows.length, l3l4Rows.length, 1);
+            for (let index = 0; index < rowCount; index += 1) {
+                rows.push(this.createMewpCoverageRow(requirement, runStatus, bugRows[index] || this.createEmptyMewpCoverageBugCell(), l3l4Rows[index] || this.createEmptyMewpCoverageL3L4Cell()));
             }
         }
         return rows;
@@ -1456,6 +1508,119 @@ class ResultDataProvider {
         })
             .sort((a, b) => String(a.requirementId).localeCompare(String(b.requirementId)));
     }
+    async buildMewpL2ToLinkedL1BaseKeys(requirements, projectName, testData) {
+        const out = new Map();
+        const relatedIds = new Set();
+        const linkedTestCaseIdsByL2 = new Map();
+        const testCaseTitleMap = this.buildMewpTestCaseTitleMap(testData);
+        for (const requirement of requirements || []) {
+            const l2BaseKey = String((requirement === null || requirement === void 0 ? void 0 : requirement.baseKey) || '').trim();
+            if (!l2BaseKey)
+                continue;
+            if (!out.has(l2BaseKey))
+                out.set(l2BaseKey, new Set());
+            if (!linkedTestCaseIdsByL2.has(l2BaseKey))
+                linkedTestCaseIdsByL2.set(l2BaseKey, new Set());
+            for (const testCaseId of (requirement === null || requirement === void 0 ? void 0 : requirement.linkedTestCaseIds) || []) {
+                const numeric = Number(testCaseId);
+                if (Number.isFinite(numeric) && numeric > 0) {
+                    linkedTestCaseIdsByL2.get(l2BaseKey).add(numeric);
+                }
+            }
+            for (const relatedId of (requirement === null || requirement === void 0 ? void 0 : requirement.relatedWorkItemIds) || []) {
+                const id = Number(relatedId);
+                if (Number.isFinite(id) && id > 0)
+                    relatedIds.add(id);
+            }
+        }
+        let titleDerivedCount = 0;
+        for (const [l2BaseKey, testCaseIds] of linkedTestCaseIdsByL2.entries()) {
+            const targetSet = out.get(l2BaseKey) || new Set();
+            for (const testCaseId of testCaseIds) {
+                const title = String(testCaseTitleMap.get(testCaseId) || '').trim();
+                if (!title)
+                    continue;
+                const fromTitleCodes = this.extractRequirementCodesFromExpectedText(title, false);
+                if (fromTitleCodes.size > 0) {
+                    for (const code of fromTitleCodes) {
+                        const normalized = this.toRequirementKey(code);
+                        if (normalized)
+                            targetSet.add(normalized);
+                    }
+                }
+                else {
+                    const normalized = this.toRequirementKey(title);
+                    if (normalized)
+                        targetSet.add(normalized);
+                }
+            }
+            if (targetSet.size > 0) {
+                titleDerivedCount += 1;
+            }
+            out.set(l2BaseKey, targetSet);
+        }
+        if (relatedIds.size === 0) {
+            const linkedL1Count = [...out.values()].reduce((sum, set) => sum + set.size, 0);
+            logger_1.default.info(`MEWP L2->L1 mapping summary: l2Families=${out.size} ` +
+                `fromTitle=${titleDerivedCount} fallbackFromLinkedL1=0 linkedL1Keys=${linkedL1Count}`);
+            return out;
+        }
+        const relatedWorkItems = await this.fetchWorkItemsByIds(projectName, [...relatedIds], false);
+        const l1BaseByWorkItemId = new Map();
+        for (const workItem of relatedWorkItems || []) {
+            const workItemId = Number((workItem === null || workItem === void 0 ? void 0 : workItem.id) || 0);
+            if (!Number.isFinite(workItemId) || workItemId <= 0)
+                continue;
+            const fields = (workItem === null || workItem === void 0 ? void 0 : workItem.fields) || {};
+            const customerId = this.extractMewpRequirementIdentifier(fields);
+            const baseKey = this.toRequirementKey(customerId);
+            if (!baseKey)
+                continue;
+            l1BaseByWorkItemId.set(workItemId, baseKey);
+        }
+        let linkedFallbackCount = 0;
+        for (const requirement of requirements || []) {
+            const l2BaseKey = String((requirement === null || requirement === void 0 ? void 0 : requirement.baseKey) || '').trim();
+            if (!l2BaseKey)
+                continue;
+            if (!out.has(l2BaseKey))
+                out.set(l2BaseKey, new Set());
+            const targetSet = out.get(l2BaseKey);
+            if (targetSet.size > 0) {
+                continue;
+            }
+            for (const relatedId of (requirement === null || requirement === void 0 ? void 0 : requirement.relatedWorkItemIds) || []) {
+                const baseKey = l1BaseByWorkItemId.get(Number(relatedId));
+                if (baseKey)
+                    targetSet.add(baseKey);
+            }
+            if (targetSet.size > 0) {
+                linkedFallbackCount += 1;
+            }
+        }
+        const l2Families = out.size;
+        const withLinkedL1 = [...out.values()].filter((set) => set.size > 0).length;
+        const linkedL1Count = [...out.values()].reduce((sum, set) => sum + set.size, 0);
+        logger_1.default.info(`MEWP L2->L1 mapping summary: l2Families=${l2Families} withLinkedL1=${withLinkedL1} ` +
+            `fromTitle=${titleDerivedCount} fallbackFromLinkedL1=${linkedFallbackCount} linkedL1Keys=${linkedL1Count}`);
+        return out;
+    }
+    buildMewpExternalJoinKeysByL2Requirement(requirements, l2ToLinkedL1BaseKeys) {
+        const out = new Map();
+        for (const requirement of requirements || []) {
+            const l2BaseKey = String((requirement === null || requirement === void 0 ? void 0 : requirement.baseKey) || '').trim();
+            if (!l2BaseKey)
+                continue;
+            const joinKeys = new Set([l2BaseKey]);
+            for (const l1Key of l2ToLinkedL1BaseKeys.get(l2BaseKey) || []) {
+                const normalized = String(l1Key || '').trim();
+                if (normalized)
+                    joinKeys.add(normalized);
+            }
+            out.set(l2BaseKey, joinKeys);
+        }
+        return out;
+    }
     buildRequirementFamilyMap(requirements, scopedRequirementKeys) {
         const familyMap = new Map();
         for (const requirement of requirements || []) {