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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elisra-devops/docgen-data-provider",
-  "version": "1.89.0",
+  "version": "1.91.0",
   "description": "A document generator data provider, aimed to retrive data from azure devops",
   "repository": {
     "type": "git",

package/src/models/mewp-reporting.ts

@@ -15,11 +15,6 @@ export interface MewpExternalFileRef {
 export interface MewpCoverageRequestOptions {
   externalBugsFile?: MewpExternalFileRef | null;
   externalL3L4File?: MewpExternalFileRef | null;
-  debugMode?: boolean;
-}
-
-export interface MewpInternalValidationRequestOptions {
-  debugMode?: boolean;
 }
 
 export interface MewpRequirementStepSummary {

package/src/modules/ResultDataProvider.ts

@@ -13,7 +13,6 @@ import type {
   MewpExternalTableValidationResult,
   MewpCoverageRow,
   MewpInternalValidationFlatPayload,
-  MewpInternalValidationRequestOptions,
   MewpInternalValidationRow,
   MewpL2RequirementFamily,
   MewpL2RequirementWorkItem,
@@ -548,9 +547,6 @@ export default class ResultDataProvider {
       const parsedDefinitionStepsByTestCase = new Map<number, TestSteps[]>();
       const testCaseStepsXmlMap = this.buildTestCaseStepsXmlMap(testData);
       const runResults = await this.fetchAllResultDataTestReporter(testData, projectName, [], false, false);
-      if (options?.debugMode) {
-        this.logMewpRunScenarioDebugMatrix(runResults, `coverage plan=${testPlanId}`);
-      }
       for (const runResult of runResults) {
         const testCaseId = this.extractMewpTestCaseId(runResult);
         const rawActionResults = Array.isArray(runResult?.iteration?.actionResults)
@@ -736,8 +732,7 @@ export default class ResultDataProvider {
     testPlanId: string,
     projectName: string,
     selectedSuiteIds: number[] | undefined,
-    linkedQueryRequest?: any,
-    options?: MewpInternalValidationRequestOptions
+    linkedQueryRequest?: any
   ): Promise<MewpInternalValidationFlatPayload> {
     const defaultPayload: MewpInternalValidationFlatPayload = {
       sheetName: `MEWP Internal Validation - Plan ${testPlanId}`,
@@ -767,6 +762,37 @@ export default class ResultDataProvider {
         allRequirements,
         scopedRequirementKeys?.size ? scopedRequirementKeys : undefined
       );
+      const linkedFullCodesByTestCase = new Map<number, Set<string>>();
+      const linkedFamilyCodesAcrossTestCases = new Map<string, Set<string>>();
+      const linkedFullCodesAcrossTestCases = new Set<string>();
+      const linkedBaseKeysAcrossTestCases = new Set<string>();
+
+      for (const [linkedTestCaseId, links] of linkedRequirementsByTestCase.entries()) {
+        const rawFullCodes = links?.fullCodes || new Set<string>();
+        const filteredFullCodes =
+          scopedRequirementKeys?.size && rawFullCodes.size > 0
+            ? new Set<string>(
+                [...rawFullCodes].filter((code) =>
+                  scopedRequirementKeys.has(this.toRequirementKey(code))
+                )
+              )
+            : rawFullCodes;
+        linkedFullCodesByTestCase.set(linkedTestCaseId, filteredFullCodes);
+
+        for (const code of filteredFullCodes) {
+          const normalizedCode = this.normalizeMewpRequirementCodeWithSuffix(code);
+          if (!normalizedCode) continue;
+          linkedFullCodesAcrossTestCases.add(normalizedCode);
+
+          const baseKey = this.toRequirementKey(normalizedCode);
+          if (!baseKey) continue;
+          linkedBaseKeysAcrossTestCases.add(baseKey);
+          if (!linkedFamilyCodesAcrossTestCases.has(baseKey)) {
+            linkedFamilyCodesAcrossTestCases.set(baseKey, new Set<string>());
+          }
+          linkedFamilyCodesAcrossTestCases.get(baseKey)!.add(normalizedCode);
+        }
+      }
 
       const rows: MewpInternalValidationRow[] = [];
       const stepsXmlByTestCase = this.buildTestCaseStepsXmlMap(testData);
@@ -796,16 +822,6 @@ export default class ResultDataProvider {
           `fromSuitePayload=${preloadedStepXmlCount} fromWorkItemFallback=${fallbackStepLoadStats.loadedFromFallback} ` +
           `stepsXmlAvailable=${stepsXmlByTestCase.size} unresolved=${fallbackStepLoadStats.unresolvedCount}`
       );
-      if (options?.debugMode) {
-        const debugRunResults = await this.fetchAllResultDataTestReporter(
-          testData,
-          projectName,
-          [],
-          false,
-          false
-        );
-        this.logMewpRunScenarioDebugMatrix(debugRunResults, `internal-validation plan=${testPlanId}`);
-      }
 
       const validL2BaseKeys = new Set<string>([...requirementFamilies.keys()]);
       const diagnostics = {
@@ -859,18 +875,7 @@ export default class ResultDataProvider {
           [...mentionedL2Only].map((code) => this.toRequirementKey(code)).filter((code) => !!code)
         );
 
-        const linkedFullCodesRaw = linkedRequirementsByTestCase.get(testCaseId)?.fullCodes || new Set<string>();
-        const linkedFullCodes =
-          scopedRequirementKeys?.size && linkedFullCodesRaw.size > 0
-            ? new Set<string>(
-                [...linkedFullCodesRaw].filter((code) =>
-                  scopedRequirementKeys.has(this.toRequirementKey(code))
-                )
-              )
-            : linkedFullCodesRaw;
-        const linkedBaseKeys = new Set<string>(
-          [...linkedFullCodes].map((code) => this.toRequirementKey(code)).filter((code) => !!code)
-        );
+        const linkedFullCodes = linkedFullCodesByTestCase.get(testCaseId) || new Set<string>();
 
         const mentionedCodesByBase = new Map<string, Set<string>>();
         for (const code of mentionedL2Only) {
@@ -880,13 +885,12 @@ export default class ResultDataProvider {
           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.
+        // 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.
+        // 2) Child mention ("SR0054-1") is exact-match and checked across scoped test cases.
         const missingBaseWhenFamilyUncovered = new Set<string>();
         const missingSpecificMentionedNoFamily = new Set<string>();
-        const missingFamilyMembers = new Set<string>();
         for (const [baseKey, mentionedCodes] of mentionedCodesByBase.entries()) {
           const familyCodes = requirementFamilies.get(baseKey);
           const mentionedCodesList = [...mentionedCodes];
@@ -894,30 +898,18 @@ export default class ResultDataProvider {
           const mentionedSpecificMembers = mentionedCodesList.filter((code) => /-\d+$/.test(code));
 
           if (familyCodes?.size) {
-            // Base mention ("SR0054") validates against child coverage when children exist.
-            // If no child variants exist, fallback to the single standalone requirement code.
+            const familyLinkedCodes = linkedFamilyCodesAcrossTestCases.get(baseKey) || new Set<string>();
+
+            // Base mention ("SR0054") is satisfied by any linked member in the same family.
             if (hasBaseMention) {
-              const familyCodesList = [...familyCodes];
-              const childFamilyCodes = familyCodesList.filter((code) => /-\d+$/.test(code));
-              const targetFamilyCodes = childFamilyCodes.length > 0 ? childFamilyCodes : familyCodesList;
-              const missingInTargetFamily = targetFamilyCodes.filter((code) => !linkedFullCodes.has(code));
-
-              if (missingInTargetFamily.length > 0) {
-                const hasAnyLinkedInFamily = familyCodesList.some((code) => linkedFullCodes.has(code));
-                if (!hasAnyLinkedInFamily) {
-                  missingBaseWhenFamilyUncovered.add(baseKey);
-                } else {
-                  for (const code of missingInTargetFamily) {
-                    missingFamilyMembers.add(code);
-                  }
-                }
+              if (familyLinkedCodes.size === 0) {
+                missingBaseWhenFamilyUncovered.add(baseKey);
               }
-              continue;
             }
 
-            // Specific mention ("SR0054-1") validates as exact-match only.
+            // Specific mention ("SR0054-1") validates as exact-match only across scoped test cases.
             for (const code of mentionedSpecificMembers) {
-              if (!linkedFullCodes.has(code)) {
+              if (!familyLinkedCodes.has(code)) {
                 missingSpecificMentionedNoFamily.add(code);
               }
             }
@@ -928,10 +920,10 @@ export default class ResultDataProvider {
           for (const code of mentionedCodes) {
             const hasSpecificSuffix = /-\d+$/.test(code);
             if (hasSpecificSuffix) {
-              if (!linkedFullCodes.has(code)) {
+              if (!linkedFullCodesAcrossTestCases.has(code)) {
                 missingSpecificMentionedNoFamily.add(code);
               }
-            } else if (!linkedBaseKeys.has(baseKey)) {
+            } else if (!linkedBaseKeysAcrossTestCases.has(baseKey)) {
               missingBaseWhenFamilyUncovered.add(baseKey);
             }
           }
@@ -961,7 +953,6 @@ export default class ResultDataProvider {
         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);
@@ -970,11 +961,6 @@ export default class ResultDataProvider {
           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);
-        }
 
         const sortedExtraLinked = [...new Set(extraLinked)]
           .map((code) => this.normalizeMewpRequirementCodeWithSuffix(code))
@@ -994,11 +980,11 @@ export default class ResultDataProvider {
             return String(a[0]).localeCompare(String(b[0]));
           })
           .map(([stepRef, requirementIds]) => {
-            const groupedRequirementList = this.formatRequirementCodesGroupedByFamily(requirementIds);
-            return `${stepRef}: ${groupedRequirementList}`;
+            return this.formatStepScopedRequirementGroups(stepRef, requirementIds);
           })
-          .join('\n');
-        const linkedButNotMentioned = this.formatRequirementCodesGroupedByFamily(sortedExtraLinked);
+          .join('\n')
+          .trim();
+        const linkedButNotMentioned = this.formatRequirementCodesGroupedByFamily(sortedExtraLinked).trim();
         const validationStatus: 'Pass' | 'Fail' =
           mentionedButNotLinked || linkedButNotMentioned ? 'Fail' : 'Pass';
         if (validationStatus === 'Fail') diagnostics.failingRows += 1;
@@ -1008,8 +994,7 @@ export default class ResultDataProvider {
             `stepsWithMentions=${mentionEntries.length} customerIdsFound=${mentionedL2Only.size} ` +
             `linkedRequirements=${linkedFullCodes.size} mentionedButNotLinked=${
               sortedMissingSpecificMentionedNoFamily.length +
-              sortedMissingBaseWhenFamilyUncovered.length +
-              sortedMissingFamilyMembers.length
+              sortedMissingBaseWhenFamilyUncovered.length
             } ` +
             `linkedButNotMentioned=${sortedExtraLinked.length} status=${validationStatus} ` +
             `customerIdSample='${[...mentionedL2Only].slice(0, 5).join(', ')}'`
@@ -2630,6 +2615,49 @@ export default class ResultDataProvider {
     return `SR${match[1]}`;
   }
 
+  private compareMewpRequirementCodes(a: string, b: string): number {
+    const normalizeComparableCode = (value: string): { base: number; hasSuffix: number; suffix: number; raw: string } => {
+      const normalizedCode = this.normalizeMewpRequirementCodeWithSuffix(value);
+      const match = /^SR(\d+)(?:-(\d+))?$/i.exec(normalizedCode);
+      if (!match) {
+        return {
+          base: Number.POSITIVE_INFINITY,
+          hasSuffix: 1,
+          suffix: Number.POSITIVE_INFINITY,
+          raw: String(value || ''),
+        };
+      }
+
+      return {
+        base: Number(match[1]),
+        hasSuffix: match[2] ? 1 : 0,
+        suffix: match[2] ? Number(match[2]) : -1,
+        raw: normalizedCode,
+      };
+    };
+
+    const left = normalizeComparableCode(a);
+    const right = normalizeComparableCode(b);
+
+    if (left.base !== right.base) return left.base - right.base;
+    if (left.hasSuffix !== right.hasSuffix) return left.hasSuffix - right.hasSuffix;
+    if (left.suffix !== right.suffix) return left.suffix - right.suffix;
+    return left.raw.localeCompare(right.raw);
+  }
+
+  private formatStepScopedRequirementGroups(stepRef: string, requirementIds: Iterable<string>): string {
+    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();
+  }
+
   private formatRequirementCodesGroupedByFamily(codes: Iterable<string>): string {
     const byBaseKey = new Map<string, Set<string>>();
     for (const rawCode of codes || []) {
@@ -2643,11 +2671,17 @@ export default class ResultDataProvider {
     if (byBaseKey.size === 0) return '';
 
     return [...byBaseKey.entries()]
-      .sort((a, b) => a[0].localeCompare(b[0]))
+      .sort((a, b) => this.compareMewpRequirementCodes(a[0], b[0]))
       .map(([baseKey, members]) => {
-        const sortedMembers = [...members].sort((a, b) => a.localeCompare(b));
+        const sortedMembers = [...members].sort((a, b) => this.compareMewpRequirementCodes(a, b));
         if (sortedMembers.length <= 1) return sortedMembers[0];
-        return `${baseKey}: ${sortedMembers.join(', ')}`;
+
+        const nonBaseMembers = sortedMembers.filter((member) => member !== baseKey);
+        if (nonBaseMembers.length > 0) {
+          return `${baseKey}: ${nonBaseMembers.join(', ')}`;
+        }
+
+        return baseKey;
       })
       .join('\n');
   }
@@ -3873,79 +3907,6 @@ export default class ResultDataProvider {
     return this.fetchResultDataBasedOnWiBase(projectName, runId, resultId);
   }
 
-  private logMewpRunScenarioDebugMatrix(runResults: any[], contextLabel: string): void {
-    const results = Array.isArray(runResults) ? runResults : [];
-    const matrix = {
-      total: results.length,
-      passOrFailWithActionResults: 0,
-      runWithNoActionResults: 0,
-      notApplicable: 0,
-      noRunHistoryActive: 0,
-      other: 0,
-    };
-    const samples = {
-      passOrFailWithActionResults: [] as number[],
-      runWithNoActionResults: [] as number[],
-      notApplicable: [] as number[],
-      noRunHistoryActive: [] as number[],
-      other: [] as number[],
-    };
-
-    const pushSample = (bucket: keyof typeof samples, id: number) => {
-      if (!Number.isFinite(id) || id <= 0) return;
-      if (samples[bucket].length >= 5) return;
-      samples[bucket].push(id);
-    };
-
-    for (const item of results) {
-      const testCaseId = Number(item?.testCaseId || item?.testCase?.id || 0);
-      const hasRun = Number(item?.lastRunId || 0) > 0 && Number(item?.lastResultId || 0) > 0;
-      const rawOutcome = String(item?._debugTestOutcome || '').trim().toLowerCase();
-      const rawState = String(item?._debugTestCaseState || '').trim().toLowerCase();
-      const originalActionResultsCount = Number(item?._debugOriginalActionResultsCount ?? -1);
-
-      if (rawOutcome === 'notapplicable' || rawOutcome === 'not applicable') {
-        matrix.notApplicable += 1;
-        pushSample('notApplicable', testCaseId);
-        continue;
-      }
-
-      if (hasRun && (rawOutcome === 'passed' || rawOutcome === 'failed') && originalActionResultsCount > 0) {
-        matrix.passOrFailWithActionResults += 1;
-        pushSample('passOrFailWithActionResults', testCaseId);
-        continue;
-      }
-
-      if (hasRun && originalActionResultsCount === 0) {
-        matrix.runWithNoActionResults += 1;
-        pushSample('runWithNoActionResults', testCaseId);
-        continue;
-      }
-
-      if (!hasRun && rawState === 'active') {
-        matrix.noRunHistoryActive += 1;
-        pushSample('noRunHistoryActive', testCaseId);
-        continue;
-      }
-
-      matrix.other += 1;
-      pushSample('other', testCaseId);
-    }
-
-    logger.info(
-      `MEWP run debug matrix (${contextLabel}): total=${matrix.total}; ` +
-        `passOrFailWithActionResults=${matrix.passOrFailWithActionResults}; ` +
-        `runWithNoActionResults=${matrix.runWithNoActionResults}; ` +
-        `notApplicable=${matrix.notApplicable}; ` +
-        `noRunHistoryActive=${matrix.noRunHistoryActive}; other=${matrix.other}; ` +
-        `samplePassFail=${samples.passOrFailWithActionResults.join(',') || '-'}; ` +
-        `sampleNoAction=${samples.runWithNoActionResults.join(',') || '-'}; ` +
-        `sampleNA=${samples.notApplicable.join(',') || '-'}; ` +
-        `sampleNoRunActive=${samples.noRunHistoryActive.join(',') || '-'}; ` +
-        `sampleOther=${samples.other.join(',') || '-'}`
-    );
-  }
-
   /**
    * Converts a run status string into a human-readable format.
    *
@@ -4381,11 +4342,6 @@ export default class ResultDataProvider {
         resultData.iterationDetails.push(iteration);
       }
 
-      const originalActionResultsCount = Array.isArray(iteration?.actionResults)
-        ? iteration.actionResults.length
-        : 0;
-      resultData._debugOriginalActionResultsCount = originalActionResultsCount;
-
       if (resultData.stepsResultXml && iteration) {
         const actionResults = Array.isArray(iteration.actionResults) ? iteration.actionResults : [];
         const actionResultsWithSharedModels = actionResults.filter(
@@ -5098,7 +5054,7 @@ export default class ResultDataProvider {
             resultData.iterationDetails?.length > 0
               ? resultData.iterationDetails[resultData.iterationDetails?.length - 1]
               : undefined;
-          const debugOutcome = this.getTestOutcome(resultData);
+          const testOutcome = this.getTestOutcome(resultData);
 
           if (!resultData?.testCase || !resultData?.testSuite) {
             logger.debug(
@@ -5132,9 +5088,6 @@ export default class ResultDataProvider {
             relatedCRs: resultData.relatedCRs || undefined,
             lastRunResult: undefined as any,
             customFields: {}, // Create an object to store custom fields
-            _debugTestOutcome: debugOutcome,
-            _debugTestCaseState: String(resultData?.state || ''),
-            _debugOriginalActionResultsCount: Number(resultData?._debugOriginalActionResultsCount ?? -1),
           };
 
           // Process all custom fields from resultData.filteredFields
@@ -5156,12 +5109,12 @@ export default class ResultDataProvider {
                 case 'testCaseResult':
                   if (lastRunId === undefined || lastResultId === undefined) {
                     resultDataResponse.testCaseResult = {
-                      resultMessage: `${this.convertRunStatus(debugOutcome)}`,
+                      resultMessage: `${this.convertRunStatus(testOutcome)}`,
                       url: '',
                     };
                   } else {
                     resultDataResponse.testCaseResult = {
-                      resultMessage: `${this.convertRunStatus(debugOutcome)} in Run ${lastRunId}`,
+                      resultMessage: `${this.convertRunStatus(testOutcome)} in Run ${lastRunId}`,
                       url: `${this.orgUrl}${projectName}/_testManagement/runs?runId=${lastRunId}&_a=resultSummary&resultId=${lastResultId}`,
                     };
                   }

package/src/tests/modules/ResultDataProvider.test.ts

@@ -1937,7 +1937,7 @@ describe('ResultDataProvider', () => {
       );
     });
 
-    it('should emit Direction A rows with step context for missing sibling links', async () => {
+    it('should emit Direction A rows only for specifically mentioned child requirements', async () => {
       jest.spyOn(resultDataProvider as any, 'fetchTestPlanName').mockResolvedValueOnce('Plan A');
       jest.spyOn(resultDataProvider as any, 'fetchTestSuites').mockResolvedValueOnce([{ testSuiteId: 1 }]);
       jest.spyOn(resultDataProvider as any, 'fetchTestData').mockResolvedValueOnce([
@@ -1981,7 +1981,7 @@ describe('ResultDataProvider', () => {
           stepId: '2',
           stepPosition: '2',
           action: '',
-          expected: 'SR0001; SR0002',
+          expected: 'SR0001-1',
           isSharedStepTitle: false,
         },
       ]);
@@ -2077,6 +2077,115 @@ describe('ResultDataProvider', () => {
       );
     });
 
+    it('should support cross-test-case family coverage when siblings are linked on different test cases', async () => {
+      jest.spyOn(resultDataProvider as any, 'fetchTestPlanName').mockResolvedValueOnce('Plan A');
+      jest.spyOn(resultDataProvider as any, 'fetchTestSuites').mockResolvedValueOnce([{ testSuiteId: 1 }]);
+      jest.spyOn(resultDataProvider as any, 'fetchTestData').mockResolvedValueOnce([
+        {
+          testPointsItems: [
+            { testCaseId: 501, testCaseName: 'TC 501 - sibling 1' },
+            { testCaseId: 502, testCaseName: 'TC 502 - sibling 2' },
+          ],
+          testCasesItems: [
+            {
+              workItem: {
+                id: 501,
+                workItemFields: [{ key: 'Steps', value: '<steps id=\"mock-steps-tc-501\"></steps>' }],
+              },
+            },
+            {
+              workItem: {
+                id: 502,
+                workItemFields: [{ key: 'Steps', value: '<steps id=\"mock-steps-tc-502\"></steps>' }],
+              },
+            },
+          ],
+        },
+      ]);
+      jest.spyOn(resultDataProvider as any, 'fetchMewpL2Requirements').mockResolvedValueOnce([
+        {
+          workItemId: 9301,
+          requirementId: 'SR0054-1',
+          baseKey: 'SR0054',
+          title: 'SR0054 child 1',
+          responsibility: 'ESUK',
+          linkedTestCaseIds: [],
+          areaPath: 'MEWP\\Customer Requirements\\Level 2',
+        },
+        {
+          workItemId: 9302,
+          requirementId: 'SR0054-2',
+          baseKey: 'SR0054',
+          title: 'SR0054 child 2',
+          responsibility: 'ESUK',
+          linkedTestCaseIds: [],
+          areaPath: 'MEWP\\Customer Requirements\\Level 2',
+        },
+      ]);
+      jest.spyOn(resultDataProvider as any, 'buildLinkedRequirementsByTestCase').mockResolvedValueOnce(
+        new Map([
+          [
+            501,
+            {
+              baseKeys: new Set(['SR0054']),
+              fullCodes: new Set(['SR0054-1']),
+            },
+          ],
+          [
+            502,
+            {
+              baseKeys: new Set(['SR0054']),
+              fullCodes: new Set(['SR0054-2']),
+            },
+          ],
+        ])
+      );
+      jest
+        .spyOn((resultDataProvider as any).testStepParserHelper, 'parseTestSteps')
+        .mockResolvedValueOnce([
+          {
+            stepId: '1',
+            stepPosition: '1',
+            action: 'Parent mention on first test case',
+            expected: 'SR0054',
+            isSharedStepTitle: false,
+          },
+        ])
+        .mockResolvedValueOnce([
+          {
+            stepId: '1',
+            stepPosition: '1',
+            action: 'Parent mention on second test case',
+            expected: 'SR0054',
+            isSharedStepTitle: false,
+          },
+        ]);
+
+      const result = await (resultDataProvider as any).getMewpInternalValidationFlatResults(
+        '123',
+        mockProjectName,
+        [1]
+      );
+
+      const byTestCase = new Map<number, any>(
+        result.rows.map((row: any) => [Number(row['Test Case ID']), row])
+      );
+      expect(byTestCase.get(501)).toEqual(
+        expect.objectContaining({
+          'Mentioned but Not Linked': '',
+          'Linked but Not Mentioned': '',
+          'Validation Status': 'Pass',
+        })
+      );
+      expect(byTestCase.get(502)).toEqual(
+        expect.objectContaining({
+          'Mentioned but Not Linked': '',
+          'Linked but Not Mentioned': '',
+          'Validation Status': 'Pass',
+        })
+      );
+    });
+
     it('should group linked-but-not-mentioned requirements by SR family', async () => {
       jest.spyOn(resultDataProvider as any, 'fetchTestPlanName').mockResolvedValueOnce('Plan A');
       jest.spyOn(resultDataProvider as any, 'fetchTestSuites').mockResolvedValueOnce([{ testSuiteId: 1 }]);
@@ -2562,7 +2671,7 @@ describe('ResultDataProvider', () => {
       expect(byTestCase.get(201)).toEqual(
         expect.objectContaining({
           'Test Case Title': 'TC 201 - Mixed discrepancies',
-          'Mentioned but Not Linked': 'Step 1: SR0095-3\nSR0511: SR0511-1, SR0511-2',
+          'Mentioned but Not Linked': 'Step 1: SR0095-3',
           'Linked but Not Mentioned': 'SR8888',
           'Validation Status': 'Fail',
         })