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

package/bin/modules/ResultDataProvider.js

@@ -558,34 +558,56 @@ 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);
+                    if (familyCodes === null || familyCodes === void 0 ? void 0 : familyCodes.size) {
+                        const missingInFamily = [...familyCodes].filter((code) => !linkedFullCodes.has(code));
+                        if (missingInFamily.length === 0)
+                            continue;
+                        const linkedInFamilyCount = familyCodes.size - missingInFamily.length;
+                        if (linkedInFamilyCount === 0) {
+                            missingBaseWhenFamilyUncovered.add(baseKey);
+                        }
+                        else {
+                            for (const code of missingInFamily) {
+                                missingFamilyMembers.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 +627,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);
@@ -645,7 +672,9 @@ class ResultDataProvider {
                 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({