@elisra-devops/docgen-data-provider 1.92.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;

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,6 +601,19 @@ 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 and considered covered only when
                 //    the whole family is covered across scoped test cases:
@@ -608,38 +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();
+                        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) {
-                            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 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".
@@ -679,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)
@@ -713,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(),
@@ -728,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],
@@ -821,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) : '';
@@ -2221,7 +2318,7 @@ class ResultDataProvider {
             // Direction B display is family-level when multiple members exist.
             return baseKey;
         })
-            .join('\n');
+            .join('; ');
     }
     toMewpComparableText(value) {
         if (value === null || value === undefined)
@@ -4200,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',