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

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],
@@ -719,7 +762,22 @@ class ResultDataProvider {
         return { l3Id: '', l3Title: '', l4Id: '', l4Title: '' };
     }
     buildMewpCoverageL3L4Rows(links) {
-        const sorted = [...(links || [])].sort((a, b) => {
+        const deduped = new Map();
+        for (const item of links || []) {
+            const level = (item === null || item === void 0 ? void 0 : item.level) === 'L4' ? 'L4' : 'L3';
+            const id = String((item === null || item === void 0 ? void 0 : item.id) || '').trim();
+            if (!id)
+                continue;
+            const key = `${level}:${id}`;
+            if (!deduped.has(key)) {
+                deduped.set(key, {
+                    id,
+                    level,
+                    title: String((item === null || item === void 0 ? void 0 : item.title) || '').trim(),
+                });
+            }
+        }
+        const sorted = [...deduped.values()].sort((a, b) => {
             if (a.level !== b.level)
                 return a.level === 'L3' ? -1 : 1;
             return String(a.id || '').localeCompare(String(b.id || ''));
@@ -736,12 +794,14 @@ class ResultDataProvider {
         }
         return rows;
     }
-    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 +823,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,7 +841,7 @@ class ResultDataProvider {
             const bugsForRows = runStatus === 'Fail'
                 ? Array.from(aggregatedBugs.values()).sort((a, b) => a.id - b.id)
                 : [];
-            const l3l4ForRows = [...(l3l4ByBaseKey.get(key) || [])];
+            const l3l4ForRows = [...externalJoinKeys].flatMap((joinKey) => l3l4ByBaseKey.get(joinKey) || []);
             const bugRows = bugsForRows.length > 0
                 ? bugsForRows
                 : [];
@@ -1456,6 +1516,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 || []) {