@elisra-devops/docgen-data-provider 1.86.0 → 1.88.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

@@ -523,6 +523,35 @@ class ResultDataProvider {
             };
             for (const testCaseId of [...allTestCaseIds].sort((a, b) => a - b)) {
                 diagnostics.totalTestCases += 1;
+                const logList = (items, max = 12) => {
+                    const values = [...items].map((item) => String(item || '').trim()).filter((item) => !!item);
+                    const shown = values.slice(0, max);
+                    const suffix = values.length > max ? ` ...(+${values.length - max} more)` : '';
+                    return shown.join(', ') + suffix;
+                };
+                const logByFamily = (items, maxFamilies = 8, maxMembers = 10) => {
+                    const map = new Map();
+                    for (const item of items || []) {
+                        const normalized = this.normalizeMewpRequirementCodeWithSuffix(String(item || ''));
+                        if (!normalized)
+                            continue;
+                        const base = this.toRequirementKey(normalized) || normalized;
+                        if (!map.has(base))
+                            map.set(base, new Set());
+                        map.get(base).add(normalized);
+                    }
+                    const entries = [...map.entries()]
+                        .sort((a, b) => a[0].localeCompare(b[0]))
+                        .slice(0, maxFamilies)
+                        .map(([base, members]) => {
+                        const sortedMembers = [...members].sort((a, b) => a.localeCompare(b));
+                        const shownMembers = sortedMembers.slice(0, maxMembers);
+                        const membersSuffix = sortedMembers.length > maxMembers ? ` ...(+${sortedMembers.length - maxMembers} more)` : '';
+                        return `${base}=[${shownMembers.join(', ')}${membersSuffix}]`;
+                    });
+                    const suffix = map.size > maxFamilies ? ` ...(+${map.size - maxFamilies} families)` : '';
+                    return entries.join(' | ') + suffix;
+                };
                 const stepsXml = stepsXmlByTestCase.get(testCaseId) || '';
                 const parsedSteps = stepsXml && String(stepsXml).trim() !== ''
                     ? await this.testStepParserHelper.parseTestSteps(stepsXml, new Map())
@@ -563,6 +592,13 @@ class ResultDataProvider {
                     ? 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 mentionStepSample = mentionEntries
+                    .slice(0, 8)
+                    .map((entry) => `${entry.stepRef}=[${logList(entry.codes, 6)}]`)
+                    .join(' | ');
+                logger_1.default.debug(`MEWP internal validation trace: testCaseId=${testCaseId} ` +
+                    `mentionSteps=${mentionEntries.length} mentionStepSample='${mentionStepSample}' ` +
+                    `mentionedL2ByFamily='${logByFamily(mentionedL2Only)}' linkedByFamily='${logByFamily(linkedFullCodes)}'`);
                 const mentionedCodesByBase = new Map();
                 for (const code of mentionedL2Only) {
                     const baseKey = this.toRequirementKey(code);
@@ -581,32 +617,85 @@ class ResultDataProvider {
                 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));
+                    let familyDecision = 'no-action';
+                    let familyTargetCodes = [];
+                    let familyMissingCodes = [];
+                    let familyLinkedCodes = [];
+                    let familyAllCodes = [];
                     if (familyCodes === null || familyCodes === void 0 ? void 0 : familyCodes.size) {
-                        const missingInFamily = [...familyCodes].filter((code) => !linkedFullCodes.has(code));
-                        if (missingInFamily.length === 0)
+                        familyAllCodes = [...familyCodes].sort((a, b) => a.localeCompare(b));
+                        familyLinkedCodes = familyAllCodes.filter((code) => linkedFullCodes.has(code));
+                        // 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;
+                            familyTargetCodes = [...targetFamilyCodes].sort((a, b) => a.localeCompare(b));
+                            const missingInTargetFamily = targetFamilyCodes.filter((code) => !linkedFullCodes.has(code));
+                            familyMissingCodes = [...missingInTargetFamily].sort((a, b) => a.localeCompare(b));
+                            if (missingInTargetFamily.length > 0) {
+                                const hasAnyLinkedInFamily = familyCodesList.some((code) => linkedFullCodes.has(code));
+                                if (!hasAnyLinkedInFamily) {
+                                    missingBaseWhenFamilyUncovered.add(baseKey);
+                                    familyDecision = 'base-mentioned-family-uncovered';
+                                }
+                                else {
+                                    for (const code of missingInTargetFamily) {
+                                        missingFamilyMembers.add(code);
+                                    }
+                                    familyDecision = 'base-mentioned-family-partial-missing-children';
+                                }
+                            }
+                            else {
+                                familyDecision = 'base-mentioned-family-fully-covered';
+                            }
+                            logger_1.default.debug(`MEWP internal validation family decision: testCaseId=${testCaseId} base=${baseKey} ` +
+                                `mode=baseMention mentioned='${logList(mentionedCodesList)}' familyAll='${logList(familyAllCodes)}' ` +
+                                `target='${logList(familyTargetCodes)}' linked='${logList(familyLinkedCodes)}' ` +
+                                `missing='${logList(familyMissingCodes)}' decision=${familyDecision}`);
                             continue;
-                        const linkedInFamilyCount = familyCodes.size - missingInFamily.length;
-                        if (linkedInFamilyCount === 0) {
-                            missingBaseWhenFamilyUncovered.add(baseKey);
                         }
-                        else {
-                            for (const code of missingInFamily) {
-                                missingFamilyMembers.add(code);
+                        // Specific mention ("SR0054-1") validates as exact-match only.
+                        const missingSpecificMembers = [];
+                        for (const code of mentionedSpecificMembers) {
+                            if (!linkedFullCodes.has(code)) {
+                                missingSpecificMentionedNoFamily.add(code);
+                                missingSpecificMembers.push(code);
                             }
                         }
+                        familyDecision =
+                            missingSpecificMembers.length > 0
+                                ? 'specific-mentioned-exact-missing'
+                                : 'specific-mentioned-exact-covered';
+                        logger_1.default.debug(`MEWP internal validation family decision: testCaseId=${testCaseId} base=${baseKey} ` +
+                            `mode=specificMention mentioned='${logList(mentionedCodesList)}' familyAll='${logList(familyAllCodes)}' ` +
+                            `linked='${logList(familyLinkedCodes)}' missingSpecific='${logList(missingSpecificMembers)}' ` +
+                            `decision=${familyDecision}`);
                         continue;
                     }
                     // Fallback path when family data is unavailable for this base key.
+                    const fallbackMissingSpecific = [];
+                    let fallbackBaseMissing = false;
                     for (const code of mentionedCodes) {
                         const hasSpecificSuffix = /-\d+$/.test(code);
                         if (hasSpecificSuffix) {
-                            if (!linkedFullCodes.has(code))
+                            if (!linkedFullCodes.has(code)) {
                                 missingSpecificMentionedNoFamily.add(code);
+                                fallbackMissingSpecific.push(code);
+                            }
                         }
                         else if (!linkedBaseKeys.has(baseKey)) {
                             missingBaseWhenFamilyUncovered.add(baseKey);
+                            fallbackBaseMissing = true;
                         }
                     }
+                    logger_1.default.debug(`MEWP internal validation family decision: testCaseId=${testCaseId} base=${baseKey} ` +
+                        `mode=noFamilyData mentioned='${logList(mentionedCodesList)}' linkedBasePresent=${linkedBaseKeys.has(baseKey)} ` +
+                        `missingSpecific='${logList(fallbackMissingSpecific)}' missingBase=${fallbackBaseMissing}`);
                 }
                 // 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".
@@ -661,11 +750,17 @@ 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 rawMentionedByStepForLog = [...mentionedButNotLinkedByStep.entries()]
+                    .map(([stepRef, requirementIds]) => `${stepRef}=[${logList(requirementIds, 8)}]`)
+                    .join(' | ');
+                logger_1.default.debug(`MEWP internal validation grouped diagnostics: testCaseId=${testCaseId} ` +
+                    `rawMentionedByStep='${rawMentionedByStepForLog}' groupedMentioned='${mentionedButNotLinked}' ` +
+                    `rawLinkedOnlyByFamily='${logByFamily(sortedExtraLinked)}' groupedLinkedOnly='${linkedButNotMentioned}'`);
                 const validationStatus = mentionedButNotLinked || linkedButNotMentioned ? 'Fail' : 'Pass';
                 if (validationStatus === 'Fail')
                     diagnostics.failingRows += 1;
@@ -2254,6 +2349,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 '';