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

package/bin/modules/ResultDataProvider.d.ts

@@ -23,6 +23,9 @@ import type { MewpCoverageFlatPayload, MewpExternalFilesValidationResponse, Mewp
  * Instantiate the class with the organization URL and token, and use the provided methods to fetch and process test data.
  */
 export default class ResultDataProvider {
+    private static readonly MEWP_INTERNAL_VALIDATION_TRACE_TAG;
+    private static readonly MEWP_INTERNAL_VALIDATION_DIAGNOSTICS_TAG;
+    private static readonly MEWP_INTERNAL_VALIDATION_SUMMARY_TAG;
     private static readonly MEWP_L2_COVERAGE_COLUMNS;
     private static readonly INTERNAL_VALIDATION_COLUMNS;
     orgUrl: string;
@@ -70,7 +73,9 @@ export default class ResultDataProvider {
      * Rows are one Requirement-TestCase pair; uncovered requirements are emitted with empty test-case columns.
      */
     getMewpL2CoverageFlatResults(testPlanId: string, projectName: string, selectedSuiteIds: number[] | undefined, linkedQueryRequest?: any, options?: MewpCoverageRequestOptions): Promise<MewpCoverageFlatPayload>;
-    getMewpInternalValidationFlatResults(testPlanId: string, projectName: string, selectedSuiteIds: number[] | undefined, linkedQueryRequest?: any): Promise<MewpInternalValidationFlatPayload>;
+    getMewpInternalValidationFlatResults(testPlanId: string, projectName: string, selectedSuiteIds: number[] | undefined, linkedQueryRequest?: any, options?: {
+        debugMode?: boolean;
+    }): Promise<MewpInternalValidationFlatPayload>;
     validateMewpExternalFiles(options: {
         externalBugsFile?: MewpExternalFileRef | null;
         externalL3L4File?: MewpExternalFileRef | null;
@@ -82,6 +87,8 @@ export default class ResultDataProvider {
     mapAttachmentsUrl(runResults: any[], project: string): any[];
     private buildMewpCoverageSheetName;
     private buildInternalValidationSheetName;
+    private formatLogValue;
+    private buildTaggedLogMessage;
     private createMewpCoverageRow;
     private createEmptyMewpCoverageBugCell;
     private createEmptyMewpCoverageL3L4Cell;
@@ -139,7 +146,6 @@ export default class ResultDataProvider {
     private normalizeMewpRequirementCode;
     private normalizeMewpRequirementCodeWithSuffix;
     private compareMewpRequirementCodes;
-    private formatStepScopedRequirementGroups;
     private formatRequirementCodesGroupedByFamily;
     private toMewpComparableText;
     private fetchTestPlanName;

package/bin/modules/ResultDataProvider.js

@@ -475,7 +475,7 @@ class ResultDataProvider {
             return defaultPayload;
         }
     }
-    async getMewpInternalValidationFlatResults(testPlanId, projectName, selectedSuiteIds, linkedQueryRequest) {
+    async getMewpInternalValidationFlatResults(testPlanId, projectName, selectedSuiteIds, linkedQueryRequest, options) {
         var _a, _b;
         const defaultPayload = {
             sheetName: `MEWP Internal Validation - Plan ${testPlanId}`,
@@ -546,8 +546,16 @@ class ResultDataProvider {
                 testCasesWithoutMentionedCustomerIds: 0,
                 failingRows: 0,
             };
+            const traceInternalValidation = (options === null || options === void 0 ? void 0 : options.debugMode) === true;
+            if (traceInternalValidation) {
+                logger_1.default.info(this.buildTaggedLogMessage(ResultDataProvider.MEWP_INTERNAL_VALIDATION_TRACE_TAG, {
+                    mode: 'enabled',
+                    source: 'ui-debug-mode',
+                }));
+            }
             for (const testCaseId of [...allTestCaseIds].sort((a, b) => a - b)) {
                 diagnostics.totalTestCases += 1;
+                const traceCurrentTestCase = traceInternalValidation;
                 const stepsXml = stepsXmlByTestCase.get(testCaseId) || '';
                 const parsedSteps = stepsXml && String(stepsXml).trim() !== ''
                     ? await this.testStepParserHelper.parseTestSteps(stepsXml, new Map())
@@ -593,9 +601,24 @@ class ResultDataProvider {
                         mentionedCodesByBase.set(baseKey, new Set());
                     mentionedCodesByBase.get(baseKey).add(code);
                 }
+                if (traceCurrentTestCase) {
+                    logger_1.default.debug(this.buildTaggedLogMessage(ResultDataProvider.MEWP_INTERNAL_VALIDATION_TRACE_TAG, {
+                        event: 'test-case-start',
+                        tc: testCaseId,
+                        parsedSteps: executableSteps.length,
+                        stepsWithMentions: mentionEntries.length,
+                        mentionedCodes: [...mentionedL2Only].sort((a, b) => this.compareMewpRequirementCodes(a, b)).join('; ') ||
+                            '<none>',
+                        linkedCodesInTestCase: [...linkedFullCodes]
+                            .sort((a, b) => this.compareMewpRequirementCodes(a, b))
+                            .join('; ') || '<none>',
+                    }));
+                }
                 // 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,32 +629,88 @@ 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.
+                        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;
+                        // Base mention ("SR0054") requires full family coverage across selected test cases.
                         if (hasBaseMention) {
-                            if (familyLinkedCodes.size === 0) {
+                            const missingRequiredFamilyMembers = requiredFamilyMembers.filter((memberCode) => !familyLinkedCodes.has(memberCode));
+                            const isWholeFamilyCovered = requiredFamilyMembers.every((memberCode) => familyLinkedCodes.has(memberCode));
+                            if (!isWholeFamilyCovered) {
                                 missingBaseWhenFamilyUncovered.add(baseKey);
                             }
+                            if (traceCurrentTestCase) {
+                                logger_1.default.debug(this.buildTaggedLogMessage(ResultDataProvider.MEWP_INTERNAL_VALIDATION_TRACE_TAG, {
+                                    event: 'base-family-coverage',
+                                    tc: testCaseId,
+                                    base: baseKey,
+                                    baseMention: true,
+                                    requiredFamily: requiredFamilyMembers
+                                        .sort((a, b) => this.compareMewpRequirementCodes(a, b))
+                                        .join('; ') || '<none>',
+                                    linkedAcrossScope: [...familyLinkedCodes]
+                                        .sort((a, b) => this.compareMewpRequirementCodes(a, b))
+                                        .join('; ') || '<none>',
+                                    missingRequired: missingRequiredFamilyMembers
+                                        .sort((a, b) => this.compareMewpRequirementCodes(a, b))
+                                        .join('; ') || '<none>',
+                                    covered: isWholeFamilyCovered,
+                                }));
+                            }
                         }
                         // Specific mention ("SR0054-1") validates as exact-match only across scoped test cases.
-                        for (const code of mentionedSpecificMembers) {
-                            if (!familyLinkedCodes.has(code)) {
-                                missingSpecificMentionedNoFamily.add(code);
-                            }
+                        const missingSpecificMembers = mentionedSpecificMembers.filter((code) => !familyLinkedCodes.has(code));
+                        for (const code of missingSpecificMembers) {
+                            missingSpecificMentionedNoFamily.add(code);
+                        }
+                        if (traceCurrentTestCase && mentionedSpecificMembers.length > 0) {
+                            logger_1.default.debug(this.buildTaggedLogMessage(ResultDataProvider.MEWP_INTERNAL_VALIDATION_TRACE_TAG, {
+                                event: 'specific-members-check',
+                                tc: testCaseId,
+                                base: baseKey,
+                                specificMentioned: mentionedSpecificMembers
+                                    .sort((a, b) => this.compareMewpRequirementCodes(a, b))
+                                    .join('; ') || '<none>',
+                                specificMissing: missingSpecificMembers
+                                    .sort((a, b) => this.compareMewpRequirementCodes(a, b))
+                                    .join('; ') || '<none>',
+                            }));
                         }
                         continue;
                     }
                     // Fallback path when family data is unavailable for this base key.
+                    const fallbackMissingSpecific = [];
+                    let fallbackMissingBase = false;
                     for (const code of mentionedCodes) {
                         const hasSpecificSuffix = /-\d+$/.test(code);
                         if (hasSpecificSuffix) {
                             if (!linkedFullCodesAcrossTestCases.has(code)) {
                                 missingSpecificMentionedNoFamily.add(code);
+                                fallbackMissingSpecific.push(code);
                             }
                         }
                         else if (!linkedBaseKeysAcrossTestCases.has(baseKey)) {
                             missingBaseWhenFamilyUncovered.add(baseKey);
+                            fallbackMissingBase = true;
                         }
                     }
+                    if (traceCurrentTestCase) {
+                        logger_1.default.debug(this.buildTaggedLogMessage(ResultDataProvider.MEWP_INTERNAL_VALIDATION_TRACE_TAG, {
+                            event: 'fallback-path',
+                            tc: testCaseId,
+                            base: baseKey,
+                            fallbackUsed: true,
+                            mentioned: mentionedCodesList
+                                .sort((a, b) => this.compareMewpRequirementCodes(a, b))
+                                .join('; ') || '<none>',
+                            missingSpecific: fallbackMissingSpecific
+                                .sort((a, b) => this.compareMewpRequirementCodes(a, b))
+                                .join('; ') || '<none>',
+                            missingBase: fallbackMissingBase,
+                        }));
+                    }
                 }
                 // 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".
@@ -648,9 +727,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));
@@ -662,6 +750,14 @@ class ResultDataProvider {
                     const stepRef = mentionedBaseFirstStep.get(baseKey) || 'Step ?';
                     appendMentionedButNotLinked(baseKey, stepRef);
                 }
+                if (traceCurrentTestCase) {
+                    logger_1.default.debug(this.buildTaggedLogMessage(ResultDataProvider.MEWP_INTERNAL_VALIDATION_TRACE_TAG, {
+                        event: 'direction-a-summary',
+                        tc: testCaseId,
+                        missingSpecific: sortedMissingSpecificMentionedNoFamily.join('; ') || '<none>',
+                        missingBase: sortedMissingBaseWhenFamilyUncovered.join('; ') || '<none>',
+                    }));
+                }
                 const sortedExtraLinked = [...new Set(extraLinked)]
                     .map((code) => this.normalizeMewpRequirementCodeWithSuffix(code))
                     .filter((code) => !!code)
@@ -679,8 +775,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();
@@ -688,13 +792,18 @@ class ResultDataProvider {
                 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=${sortedMissingSpecificMentionedNoFamily.length +
-                        sortedMissingBaseWhenFamilyUncovered.length} ` +
-                    `linkedButNotMentioned=${sortedExtraLinked.length} status=${validationStatus} ` +
-                    `customerIdSample='${[...mentionedL2Only].slice(0, 5).join(', ')}'`);
+                logger_1.default.debug(this.buildTaggedLogMessage(ResultDataProvider.MEWP_INTERNAL_VALIDATION_DIAGNOSTICS_TAG, {
+                    testCaseId,
+                    parsedSteps: executableSteps.length,
+                    stepsWithMentions: mentionEntries.length,
+                    customerIdsFound: mentionedL2Only.size,
+                    linkedRequirements: linkedFullCodes.size,
+                    mentionedButNotLinked: sortedMissingSpecificMentionedNoFamily.length +
+                        sortedMissingBaseWhenFamilyUncovered.length,
+                    linkedButNotMentioned: sortedExtraLinked.length,
+                    status: validationStatus,
+                    customerIdSample: [...mentionedL2Only].slice(0, 5).join(', '),
+                }));
                 rows.push({
                     'Test Case ID': testCaseId,
                     'Test Case Title': String(testCaseTitleMap.get(testCaseId) || '').trim(),
@@ -703,11 +812,14 @@ class ResultDataProvider {
                     'Validation Status': validationStatus,
                 });
             }
-            logger_1.default.info(`MEWP internal validation summary: testCases=${diagnostics.totalTestCases} ` +
-                `parsedSteps=${diagnostics.totalParsedSteps} stepsWithMentions=${diagnostics.totalStepsWithMentions} ` +
-                `totalCustomerIdsFound=${diagnostics.totalMentionedCustomerIds} ` +
-                `testCasesWithoutCustomerIds=${diagnostics.testCasesWithoutMentionedCustomerIds} ` +
-                `failingRows=${diagnostics.failingRows}`);
+            logger_1.default.info(this.buildTaggedLogMessage(ResultDataProvider.MEWP_INTERNAL_VALIDATION_SUMMARY_TAG, {
+                testCases: diagnostics.totalTestCases,
+                parsedSteps: diagnostics.totalParsedSteps,
+                stepsWithMentions: diagnostics.totalStepsWithMentions,
+                totalCustomerIdsFound: diagnostics.totalMentionedCustomerIds,
+                testCasesWithoutCustomerIds: diagnostics.testCasesWithoutMentionedCustomerIds,
+                failingRows: diagnostics.failingRows,
+            }));
             return {
                 sheetName: this.buildInternalValidationSheetName(planName, testPlanId),
                 columnOrder: [...ResultDataProvider.INTERNAL_VALIDATION_COLUMNS],
@@ -796,6 +908,16 @@ class ResultDataProvider {
         const suffix = String(planName || '').trim() || `Plan ${testPlanId}`;
         return `MEWP Internal Validation - ${suffix}`;
     }
+    formatLogValue(value) {
+        if (value === null || value === undefined)
+            return '<none>';
+        const asText = String(value).trim();
+        return asText !== '' ? asText : '<none>';
+    }
+    buildTaggedLogMessage(tag, fields) {
+        const sections = Object.entries(fields).map(([key, value]) => `${key}=${this.formatLogValue(value)}`);
+        return `${tag} ${sections.join(' | ')}`;
+    }
     createMewpCoverageRow(requirement, runStatus, bug, linkedL3L4) {
         const l2ReqIdNumeric = Number((requirement === null || requirement === void 0 ? void 0 : requirement.workItemId) || 0);
         const l2ReqId = l2ReqIdNumeric > 0 ? String(l2ReqIdNumeric) : '';
@@ -2174,18 +2296,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,13 +2315,10 @@ 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');
+            .join('; ');
     }
     toMewpComparableText(value) {
         if (value === null || value === undefined)
@@ -4190,6 +4297,9 @@ class ResultDataProvider {
         return customFields;
     }
 }
+ResultDataProvider.MEWP_INTERNAL_VALIDATION_TRACE_TAG = '[MEWP][InternalValidation][Trace]';
+ResultDataProvider.MEWP_INTERNAL_VALIDATION_DIAGNOSTICS_TAG = '[MEWP][InternalValidation][Diagnostics]';
+ResultDataProvider.MEWP_INTERNAL_VALIDATION_SUMMARY_TAG = '[MEWP][InternalValidation][Summary]';
 ResultDataProvider.MEWP_L2_COVERAGE_COLUMNS = [
     'L2 REQ ID',
     'L2 REQ Title',