@elisra-devops/docgen-data-provider 1.85.0 → 1.87.0

package/bin/modules/ResultDataProvider.d.ts

@@ -142,6 +142,7 @@ export default class ResultDataProvider {
     private isExcludedL3L4BySapWbs;
     private normalizeMewpRequirementCode;
     private normalizeMewpRequirementCodeWithSuffix;
+    private formatRequirementCodesGroupedByFamily;
     private toMewpComparableText;
     private fetchTestPlanName;
     /**

package/bin/modules/ResultDataProvider.js

@@ -558,34 +558,73 @@ class ResultDataProvider {
                     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) {
-                    const familyCodes = requirementFamilies.get(baseKey);
-                    if (familyCodes === null || familyCodes === void 0 ? void 0 : familyCodes.size) {
-                        familyCodes.forEach((code) => expectedFamilyCodes.add(code));
-                    }
-                    else {
-                        for (const code of mentionedL2Only) {
-                            if (this.toRequirementKey(code) === baseKey)
-                                expectedFamilyCodes.add(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 missingMentioned = [...mentionedL2Only].filter((code) => {
+                const mentionedCodesByBase = new Map();
+                for (const code of mentionedL2Only) {
                     const baseKey = this.toRequirementKey(code);
                     if (!baseKey)
-                        return false;
-                    const hasSpecificSuffix = /-\d+$/.test(code);
-                    if (hasSpecificSuffix)
-                        return !linkedFullCodes.has(code);
-                    return !linkedBaseKeys.has(baseKey);
-                });
-                const missingFamily = [...expectedFamilyCodes].filter((code) => !linkedFullCodes.has(code));
+                        continue;
+                    if (!mentionedCodesByBase.has(baseKey))
+                        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.
+                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.
+                        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);
+                                    }
+                                }
+                            }
+                            continue;
+                        }
+                        // Specific mention ("SR0054-1") validates as exact-match only.
+                        for (const code of mentionedSpecificMembers) {
+                            if (!linkedFullCodes.has(code)) {
+                                missingSpecificMentionedNoFamily.add(code);
+                            }
+                        }
+                        continue;
+                    }
+                    // Fallback path when family data is unavailable for this base key.
+                    for (const code of mentionedCodes) {
+                        const hasSpecificSuffix = /-\d+$/.test(code);
+                        if (hasSpecificSuffix) {
+                            if (!linkedFullCodes.has(code))
+                                missingSpecificMentionedNoFamily.add(code);
+                        }
+                        else if (!linkedBaseKeys.has(baseKey)) {
+                            missingBaseWhenFamilyUncovered.add(baseKey);
+                        }
+                    }
+                }
                 // Direction B is family-based: if any member of a family is mentioned in Expected Result,
                 // linked members of that same family are not considered "linked but not mentioned".
                 const extraLinked = [...linkedFullCodes].filter((code) => {
@@ -605,13 +644,18 @@ class ResultDataProvider {
                     }
                     mentionedButNotLinkedByStep.get(normalizedStepRef).add(normalizedRequirementId);
                 };
-                const sortedMissingMentioned = [...new Set(missingMentioned)].sort((a, b) => a.localeCompare(b));
-                const sortedMissingFamily = [...new Set(missingFamily)].sort((a, b) => a.localeCompare(b));
-                for (const code of sortedMissingMentioned) {
+                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);
                 }
-                for (const code of sortedMissingFamily) {
+                for (const baseKey of sortedMissingBaseWhenFamilyUncovered) {
+                    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);
@@ -634,18 +678,20 @@ class ResultDataProvider {
                     return String(a[0]).localeCompare(String(b[0]));
                 })
                     .map(([stepRef, requirementIds]) => {
-                    const requirementList = [...requirementIds].sort((a, b) => a.localeCompare(b));
-                    return `${stepRef}: ${requirementList.join(', ')}`;
+                    const groupedRequirementList = this.formatRequirementCodesGroupedByFamily(requirementIds);
+                    return `${stepRef}: ${groupedRequirementList}`;
                 })
                     .join('; ');
-                const linkedButNotMentioned = sortedExtraLinked.join('; ');
+                const linkedButNotMentioned = this.formatRequirementCodesGroupedByFamily(sortedExtraLinked);
                 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} ` +
+                    `linkedRequirements=${linkedFullCodes.size} mentionedButNotLinked=${sortedMissingSpecificMentionedNoFamily.length +
+                        sortedMissingBaseWhenFamilyUncovered.length +
+                        sortedMissingFamilyMembers.length} ` +
                     `linkedButNotMentioned=${sortedExtraLinked.length} status=${validationStatus} ` +
                     `customerIdSample='${[...mentionedL2Only].slice(0, 5).join(', ')}'`);
                 rows.push({
@@ -2225,6 +2271,29 @@ class ResultDataProvider {
             return `SR${match[1]}-${match[2]}`;
         return `SR${match[1]}`;
     }
+    formatRequirementCodesGroupedByFamily(codes) {
+        const byBaseKey = new Map();
+        for (const rawCode of codes || []) {
+            const normalizedCode = this.normalizeMewpRequirementCodeWithSuffix(String(rawCode || ''));
+            if (!normalizedCode)
+                continue;
+            const baseKey = this.toRequirementKey(normalizedCode) || normalizedCode;
+            if (!byBaseKey.has(baseKey))
+                byBaseKey.set(baseKey, new Set());
+            byBaseKey.get(baseKey).add(normalizedCode);
+        }
+        if (byBaseKey.size === 0)
+            return '';
+        return [...byBaseKey.entries()]
+            .sort((a, b) => a[0].localeCompare(b[0]))
+            .map(([baseKey, members]) => {
+            const sortedMembers = [...members].sort((a, b) => a.localeCompare(b));
+            if (sortedMembers.length <= 1)
+                return sortedMembers[0];
+            return `${baseKey}: ${sortedMembers.join(', ')}`;
+        })
+            .join('; ');
+    }
     toMewpComparableText(value) {
         if (value === null || value === undefined)
             return '';