@elisra-devops/docgen-data-provider 1.90.0 → 1.92.0

package/bin/modules/ResultDataProvider.d.ts

@@ -138,6 +138,7 @@ export default class ResultDataProvider {
     private isExcludedL3L4BySapWbs;
     private normalizeMewpRequirementCode;
     private normalizeMewpRequirementCodeWithSuffix;
+    private compareMewpRequirementCodes;
     private formatRequirementCodesGroupedByFamily;
     private toMewpComparableText;
     private fetchTestPlanName;

package/bin/modules/ResultDataProvider.js

@@ -476,7 +476,7 @@ class ResultDataProvider {
         }
     }
     async getMewpInternalValidationFlatResults(testPlanId, projectName, selectedSuiteIds, linkedQueryRequest) {
-        var _a, _b, _c;
+        var _a, _b;
         const defaultPayload = {
             sheetName: `MEWP Internal Validation - Plan ${testPlanId}`,
             columnOrder: [...ResultDataProvider.INTERNAL_VALIDATION_COLUMNS],
@@ -489,6 +489,31 @@ class ResultDataProvider {
             const linkedRequirementsByTestCase = await this.buildLinkedRequirementsByTestCase(allRequirements, testData, projectName);
             const scopedRequirementKeys = await this.resolveMewpRequirementScopeKeysFromQuery(linkedQueryRequest, allRequirements, linkedRequirementsByTestCase);
             const requirementFamilies = this.buildRequirementFamilyMap(allRequirements, (scopedRequirementKeys === null || scopedRequirementKeys === void 0 ? void 0 : scopedRequirementKeys.size) ? scopedRequirementKeys : undefined);
+            const linkedFullCodesByTestCase = new Map();
+            const linkedFamilyCodesAcrossTestCases = new Map();
+            const linkedFullCodesAcrossTestCases = new Set();
+            const linkedBaseKeysAcrossTestCases = new Set();
+            for (const [linkedTestCaseId, links] of linkedRequirementsByTestCase.entries()) {
+                const rawFullCodes = (links === null || links === void 0 ? void 0 : links.fullCodes) || new Set();
+                const filteredFullCodes = (scopedRequirementKeys === null || scopedRequirementKeys === void 0 ? void 0 : scopedRequirementKeys.size) && rawFullCodes.size > 0
+                    ? new Set([...rawFullCodes].filter((code) => scopedRequirementKeys.has(this.toRequirementKey(code))))
+                    : rawFullCodes;
+                linkedFullCodesByTestCase.set(linkedTestCaseId, filteredFullCodes);
+                for (const code of filteredFullCodes) {
+                    const normalizedCode = this.normalizeMewpRequirementCodeWithSuffix(code);
+                    if (!normalizedCode)
+                        continue;
+                    linkedFullCodesAcrossTestCases.add(normalizedCode);
+                    const baseKey = this.toRequirementKey(normalizedCode);
+                    if (!baseKey)
+                        continue;
+                    linkedBaseKeysAcrossTestCases.add(baseKey);
+                    if (!linkedFamilyCodesAcrossTestCases.has(baseKey)) {
+                        linkedFamilyCodesAcrossTestCases.set(baseKey, new Set());
+                    }
+                    linkedFamilyCodesAcrossTestCases.get(baseKey).add(normalizedCode);
+                }
+            }
             const rows = [];
             const stepsXmlByTestCase = this.buildTestCaseStepsXmlMap(testData);
             const testCaseTitleMap = this.buildMewpTestCaseTitleMap(testData);
@@ -558,11 +583,7 @@ class ResultDataProvider {
                     diagnostics.testCasesWithoutMentionedCustomerIds += 1;
                 }
                 const mentionedBaseKeys = new Set([...mentionedL2Only].map((code) => this.toRequirementKey(code)).filter((code) => !!code));
-                const linkedFullCodesRaw = ((_c = linkedRequirementsByTestCase.get(testCaseId)) === null || _c === void 0 ? void 0 : _c.fullCodes) || new Set();
-                const linkedFullCodes = (scopedRequirementKeys === null || scopedRequirementKeys === void 0 ? void 0 : scopedRequirementKeys.size) && linkedFullCodesRaw.size > 0
-                    ? new Set([...linkedFullCodesRaw].filter((code) => scopedRequirementKeys.has(this.toRequirementKey(code))))
-                    : linkedFullCodesRaw;
-                const linkedBaseKeys = new Set([...linkedFullCodes].map((code) => this.toRequirementKey(code)).filter((code) => !!code));
+                const linkedFullCodes = linkedFullCodesByTestCase.get(testCaseId) || new Set();
                 const mentionedCodesByBase = new Map();
                 for (const code of mentionedL2Only) {
                     const baseKey = this.toRequirementKey(code);
@@ -572,42 +593,36 @@ class ResultDataProvider {
                         mentionedCodesByBase.set(baseKey, new Set());
                     mentionedCodesByBase.get(baseKey).add(code);
                 }
-                // Context-based direction A logic:
-                // 1) If no member of family is linked -> report only base SR (Step X: SR0054).
-                // 2) If family is partially linked -> report only specific missing members.
-                // 3) If family fully linked -> report nothing for that family.
+                // Direction A logic:
+                // 1) Base mention ("SR0054") is parent-level and considered covered only when
+                //    the whole family is covered across scoped test cases:
+                //    - if family has children, all children must be linked;
+                //    - if family has no children, the base item itself must be linked.
+                // 2) Child mention ("SR0054-1") is exact-match and checked across scoped test cases.
                 const missingBaseWhenFamilyUncovered = new Set();
                 const missingSpecificMentionedNoFamily = new Set();
-                const missingFamilyMembers = new Set();
                 for (const [baseKey, mentionedCodes] of mentionedCodesByBase.entries()) {
                     const familyCodes = requirementFamilies.get(baseKey);
                     const mentionedCodesList = [...mentionedCodes];
                     const hasBaseMention = mentionedCodesList.some((code) => !/-\d+$/.test(code));
                     const mentionedSpecificMembers = mentionedCodesList.filter((code) => /-\d+$/.test(code));
                     if (familyCodes === null || familyCodes === void 0 ? void 0 : familyCodes.size) {
-                        // Base mention ("SR0054") validates against child coverage when children exist.
-                        // If no child variants exist, fallback to the single standalone requirement code.
+                        const familyLinkedCodes = linkedFamilyCodesAcrossTestCases.get(baseKey) || new Set();
+                        // Base mention ("SR0054") requires full family coverage across selected test cases.
                         if (hasBaseMention) {
-                            const familyCodesList = [...familyCodes];
-                            const childFamilyCodes = familyCodesList.filter((code) => /-\d+$/.test(code));
-                            const targetFamilyCodes = childFamilyCodes.length > 0 ? childFamilyCodes : familyCodesList;
-                            const missingInTargetFamily = targetFamilyCodes.filter((code) => !linkedFullCodes.has(code));
-                            if (missingInTargetFamily.length > 0) {
-                                const hasAnyLinkedInFamily = familyCodesList.some((code) => linkedFullCodes.has(code));
-                                if (!hasAnyLinkedInFamily) {
-                                    missingBaseWhenFamilyUncovered.add(baseKey);
-                                }
-                                else {
-                                    for (const code of missingInTargetFamily) {
-                                        missingFamilyMembers.add(code);
-                                    }
-                                }
+                            const normalizedFamilyMembers = [...familyCodes]
+                                .map((code) => this.normalizeMewpRequirementCodeWithSuffix(code))
+                                .filter((code) => !!code);
+                            const specificFamilyMembers = normalizedFamilyMembers.filter((code) => /-\d+$/.test(code));
+                            const requiredFamilyMembers = specificFamilyMembers.length > 0 ? specificFamilyMembers : normalizedFamilyMembers;
+                            const isWholeFamilyCovered = requiredFamilyMembers.every((memberCode) => familyLinkedCodes.has(memberCode));
+                            if (!isWholeFamilyCovered) {
+                                missingBaseWhenFamilyUncovered.add(baseKey);
                             }
-                            continue;
                         }
-                        // Specific mention ("SR0054-1") validates as exact-match only.
+                        // Specific mention ("SR0054-1") validates as exact-match only across scoped test cases.
                         for (const code of mentionedSpecificMembers) {
-                            if (!linkedFullCodes.has(code)) {
+                            if (!familyLinkedCodes.has(code)) {
                                 missingSpecificMentionedNoFamily.add(code);
                             }
                         }
@@ -617,11 +632,11 @@ class ResultDataProvider {
                     for (const code of mentionedCodes) {
                         const hasSpecificSuffix = /-\d+$/.test(code);
                         if (hasSpecificSuffix) {
-                            if (!linkedFullCodes.has(code)) {
+                            if (!linkedFullCodesAcrossTestCases.has(code)) {
                                 missingSpecificMentionedNoFamily.add(code);
                             }
                         }
-                        else if (!linkedBaseKeys.has(baseKey)) {
+                        else if (!linkedBaseKeysAcrossTestCases.has(baseKey)) {
                             missingBaseWhenFamilyUncovered.add(baseKey);
                         }
                     }
@@ -641,13 +656,21 @@ class ResultDataProvider {
                         return;
                     const normalizedStepRef = String(stepRef || 'Step ?').trim() || 'Step ?';
                     if (!mentionedButNotLinkedByStep.has(normalizedStepRef)) {
-                        mentionedButNotLinkedByStep.set(normalizedStepRef, new Set());
+                        mentionedButNotLinkedByStep.set(normalizedStepRef, {
+                            baseIds: new Set(),
+                            specificIds: new Set(),
+                        });
+                    }
+                    const entry = mentionedButNotLinkedByStep.get(normalizedStepRef);
+                    if (/-\d+$/.test(normalizedRequirementId)) {
+                        entry.specificIds.add(normalizedRequirementId);
+                    }
+                    else {
+                        entry.baseIds.add(normalizedRequirementId);
                     }
-                    mentionedButNotLinkedByStep.get(normalizedStepRef).add(normalizedRequirementId);
                 };
                 const sortedMissingSpecificMentionedNoFamily = [...missingSpecificMentionedNoFamily].sort((a, b) => a.localeCompare(b));
                 const sortedMissingBaseWhenFamilyUncovered = [...missingBaseWhenFamilyUncovered].sort((a, b) => a.localeCompare(b));
-                const sortedMissingFamilyMembers = [...missingFamilyMembers].sort((a, b) => a.localeCompare(b));
                 for (const code of sortedMissingSpecificMentionedNoFamily) {
                     const stepRef = mentionedCodeFirstStep.get(code) || 'Step ?';
                     appendMentionedButNotLinked(code, stepRef);
@@ -656,11 +679,6 @@ class ResultDataProvider {
                     const stepRef = mentionedBaseFirstStep.get(baseKey) || 'Step ?';
                     appendMentionedButNotLinked(baseKey, stepRef);
                 }
-                for (const code of sortedMissingFamilyMembers) {
-                    const baseKey = this.toRequirementKey(code);
-                    const stepRef = mentionedBaseFirstStep.get(baseKey) || 'Step ?';
-                    appendMentionedButNotLinked(code, stepRef);
-                }
                 const sortedExtraLinked = [...new Set(extraLinked)]
                     .map((code) => this.normalizeMewpRequirementCodeWithSuffix(code))
                     .filter((code) => !!code)
@@ -678,12 +696,20 @@ class ResultDataProvider {
                         return stepOrderA - stepOrderB;
                     return String(a[0]).localeCompare(String(b[0]));
                 })
-                    .map(([stepRef, requirementIds]) => {
-                    const groupedRequirementList = this.formatRequirementCodesGroupedByFamily(requirementIds);
-                    return `${stepRef}: ${groupedRequirementList}`;
+                    .map(([stepRef, requirementIdsByType]) => {
+                    const specificCodes = [...requirementIdsByType.specificIds].sort((a, b) => this.compareMewpRequirementCodes(a, b));
+                    const specificFamilies = new Set(specificCodes.map((code) => this.toRequirementKey(code)).filter((code) => !!code));
+                    const baseCodes = [...requirementIdsByType.baseIds]
+                        .filter((baseCode) => !specificFamilies.has(baseCode))
+                        .sort((a, b) => this.compareMewpRequirementCodes(a, b));
+                    const displayCodes = [...specificCodes, ...baseCodes];
+                    if (displayCodes.length === 0)
+                        return `${stepRef}:`;
+                    return `${stepRef}: ${displayCodes.join('; ')}`.trim();
                 })
-                    .join('\n');
-                const linkedButNotMentioned = this.formatRequirementCodesGroupedByFamily(sortedExtraLinked);
+                    .join('\n')
+                    .trim();
+                const linkedButNotMentioned = this.formatRequirementCodesGroupedByFamily(sortedExtraLinked).trim();
                 const validationStatus = mentionedButNotLinked || linkedButNotMentioned ? 'Fail' : 'Pass';
                 if (validationStatus === 'Fail')
                     diagnostics.failingRows += 1;
@@ -691,8 +717,7 @@ class ResultDataProvider {
                     `testCaseId=${testCaseId} parsedSteps=${executableSteps.length} ` +
                     `stepsWithMentions=${mentionEntries.length} customerIdsFound=${mentionedL2Only.size} ` +
                     `linkedRequirements=${linkedFullCodes.size} mentionedButNotLinked=${sortedMissingSpecificMentionedNoFamily.length +
-                        sortedMissingBaseWhenFamilyUncovered.length +
-                        sortedMissingFamilyMembers.length} ` +
+                        sortedMissingBaseWhenFamilyUncovered.length} ` +
                     `linkedButNotMentioned=${sortedExtraLinked.length} status=${validationStatus} ` +
                     `customerIdSample='${[...mentionedL2Only].slice(0, 5).join(', ')}'`);
                 rows.push({
@@ -2145,6 +2170,35 @@ class ResultDataProvider {
             return `SR${match[1]}-${match[2]}`;
         return `SR${match[1]}`;
     }
+    compareMewpRequirementCodes(a, b) {
+        const normalizeComparableCode = (value) => {
+            const normalizedCode = this.normalizeMewpRequirementCodeWithSuffix(value);
+            const match = /^SR(\d+)(?:-(\d+))?$/i.exec(normalizedCode);
+            if (!match) {
+                return {
+                    base: Number.POSITIVE_INFINITY,
+                    hasSuffix: 1,
+                    suffix: Number.POSITIVE_INFINITY,
+                    raw: String(value || ''),
+                };
+            }
+            return {
+                base: Number(match[1]),
+                hasSuffix: match[2] ? 1 : 0,
+                suffix: match[2] ? Number(match[2]) : -1,
+                raw: normalizedCode,
+            };
+        };
+        const left = normalizeComparableCode(a);
+        const right = normalizeComparableCode(b);
+        if (left.base !== right.base)
+            return left.base - right.base;
+        if (left.hasSuffix !== right.hasSuffix)
+            return left.hasSuffix - right.hasSuffix;
+        if (left.suffix !== right.suffix)
+            return left.suffix - right.suffix;
+        return left.raw.localeCompare(right.raw);
+    }
     formatRequirementCodesGroupedByFamily(codes) {
         const byBaseKey = new Map();
         for (const rawCode of codes || []) {
@@ -2159,12 +2213,13 @@ class ResultDataProvider {
         if (byBaseKey.size === 0)
             return '';
         return [...byBaseKey.entries()]
-            .sort((a, b) => a[0].localeCompare(b[0]))
+            .sort((a, b) => this.compareMewpRequirementCodes(a[0], b[0]))
             .map(([baseKey, members]) => {
-            const sortedMembers = [...members].sort((a, b) => a.localeCompare(b));
+            const sortedMembers = [...members].sort((a, b) => this.compareMewpRequirementCodes(a, b));
             if (sortedMembers.length <= 1)
                 return sortedMembers[0];
-            return `${baseKey}: ${sortedMembers.join(', ')}`;
+            // Direction B display is family-level when multiple members exist.
+            return baseKey;
         })
             .join('\n');
     }