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

package/bin/modules/ResultDataProvider.d.ts

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

package/bin/modules/ResultDataProvider.js

@@ -594,8 +594,10 @@ class ResultDataProvider {
                     mentionedCodesByBase.get(baseKey).add(code);
                 }
                 // Direction A logic:
-                // 1) Base mention ("SR0054") is parent-level only and considered covered
-                //    if any member of that family is linked across scoped test cases.
+                // 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();
@@ -606,9 +608,15 @@ class ResultDataProvider {
                     const mentionedSpecificMembers = mentionedCodesList.filter((code) => /-\d+$/.test(code));
                     if (familyCodes === null || familyCodes === void 0 ? void 0 : familyCodes.size) {
                         const familyLinkedCodes = linkedFamilyCodesAcrossTestCases.get(baseKey) || new Set();
-                        // Base mention ("SR0054") is satisfied by any linked member in the same family.
+                        // Base mention ("SR0054") requires full family coverage across selected test cases.
                         if (hasBaseMention) {
-                            if (familyLinkedCodes.size === 0) {
+                            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);
                             }
                         }
@@ -648,9 +656,18 @@ 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));
@@ -679,8 +696,16 @@ class ResultDataProvider {
                         return stepOrderA - stepOrderB;
                     return String(a[0]).localeCompare(String(b[0]));
                 })
-                    .map(([stepRef, requirementIds]) => {
-                    return this.formatStepScopedRequirementGroups(stepRef, requirementIds);
+                    .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')
                     .trim();
@@ -2174,18 +2199,6 @@ class ResultDataProvider {
             return left.suffix - right.suffix;
         return left.raw.localeCompare(right.raw);
     }
-    formatStepScopedRequirementGroups(stepRef, requirementIds) {
-        const groupedRequirementList = this.formatRequirementCodesGroupedByFamily(requirementIds);
-        if (!groupedRequirementList)
-            return `${stepRef}:`;
-        const groupedLines = groupedRequirementList
-            .split('\n')
-            .map((line) => String(line || '').trim())
-            .filter((line) => line.length > 0);
-        if (groupedLines.length <= 1)
-            return `${stepRef}: ${groupedLines[0] || ''}`.trim();
-        return `${stepRef}:\n${groupedLines.map((line) => `- ${line}`).join('\n')}`.trim();
-    }
     formatRequirementCodesGroupedByFamily(codes) {
         const byBaseKey = new Map();
         for (const rawCode of codes || []) {
@@ -2205,10 +2218,7 @@ class ResultDataProvider {
             const sortedMembers = [...members].sort((a, b) => this.compareMewpRequirementCodes(a, b));
             if (sortedMembers.length <= 1)
                 return sortedMembers[0];
-            const nonBaseMembers = sortedMembers.filter((member) => member !== baseKey);
-            if (nonBaseMembers.length > 0) {
-                return `${baseKey}: ${nonBaseMembers.join(', ')}`;
-            }
+            // Direction B display is family-level when multiple members exist.
             return baseKey;
         })
             .join('\n');