@elisra-devops/docgen-data-provider 1.102.0 → 1.104.0

package/package.json

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

package/src/models/mewp-reporting.ts

@@ -28,6 +28,7 @@ export interface MewpL2RequirementWorkItem {
   requirementId: string;
   baseKey: string;
   title: string;
+  owner: string;
   subSystem: string;
   responsibility: string;
   linkedTestCaseIds: number[];
@@ -40,6 +41,7 @@ export interface MewpL2RequirementFamily {
   requirementId: string;
   baseKey: string;
   title: string;
+  owner: string;
   subSystem: string;
   responsibility: string;
   linkedTestCaseIds: number[];
@@ -84,7 +86,10 @@ export type MewpCoverageL3L4Cell = MewpL3L4Pair;
 
 export interface MewpCoverageRow {
   'L2 REQ ID': string;
+  'SR #': string;
   'L2 REQ Title': string;
+  'L2 REQ Full Title'?: string;
+  'L2 Owner': string;
   'L2 SubSystem': string;
   'L2 Run Status': MewpRunStatus;
   'Bug ID': number | '';

package/src/modules/ResultDataProvider.ts

@@ -61,7 +61,9 @@ export default class ResultDataProvider {
 
   private static readonly MEWP_L2_COVERAGE_COLUMNS = [
     'L2 REQ ID',
+    'SR #',
     'L2 REQ Title',
+    'L2 Owner',
     'L2 SubSystem',
     'L2 Run Status',
     'Bug ID',
@@ -824,6 +826,13 @@ export default class ResultDataProvider {
       }
 
       const preloadedStepXmlCount = stepsXmlByTestCase.size;
+      const latestWorkItemMapStats = await this.enrichMewpTestCaseMapsFromLatestWorkItems(
+        projectName,
+        [...allTestCaseIds],
+        stepsXmlByTestCase,
+        testCaseTitleMap,
+        testCaseDescriptionMap
+      );
       const fallbackStepLoadStats = await this.enrichMewpStepsXmlMapFromWorkItems(
         projectName,
         [...allTestCaseIds],
@@ -831,7 +840,11 @@ export default class ResultDataProvider {
       );
       logger.info(
         `MEWP internal validation steps source summary: testCases=${allTestCaseIds.size} ` +
-          `fromSuitePayload=${preloadedStepXmlCount} fromWorkItemFallback=${fallbackStepLoadStats.loadedFromFallback} ` +
+          `fromSuitePayload=${preloadedStepXmlCount} ` +
+          `fromLatestWorkItem=${latestWorkItemMapStats.stepsLoadedFromLatest} ` +
+          `titleFromLatest=${latestWorkItemMapStats.titleLoadedFromLatest} ` +
+          `descriptionFromLatest=${latestWorkItemMapStats.descriptionLoadedFromLatest} ` +
+          `fromWorkItemFallback=${fallbackStepLoadStats.loadedFromFallback} ` +
           `stepsXmlAvailable=${stepsXmlByTestCase.size} unresolved=${fallbackStepLoadStats.unresolvedCount}`
       );
 
@@ -915,24 +928,6 @@ export default class ResultDataProvider {
           if (!mentionedCodesByBase.has(baseKey)) mentionedCodesByBase.set(baseKey, new Set<string>());
           mentionedCodesByBase.get(baseKey)!.add(code);
         }
-        if (traceCurrentTestCase) {
-          logger.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:
@@ -958,38 +953,12 @@ export default class ResultDataProvider {
 
             // Base mention ("SR0054") requires full family coverage across selected test cases.
             if (hasBaseMention) {
-              const missingRequiredFamilyMembers = requiredFamilyMembers.filter(
-                (memberCode) => !familyLinkedCodes.has(memberCode)
-              );
               const isWholeFamilyCovered = requiredFamilyMembers.every((memberCode) =>
                 familyLinkedCodes.has(memberCode)
               );
               if (!isWholeFamilyCovered) {
                 missingBaseWhenFamilyUncovered.add(baseKey);
               }
-              if (traceCurrentTestCase) {
-                logger.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.
@@ -999,60 +968,20 @@ export default class ResultDataProvider {
             for (const code of missingSpecificMembers) {
               missingSpecificMentionedNoFamily.add(code);
             }
-            if (traceCurrentTestCase && mentionedSpecificMembers.length > 0) {
-              logger.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: string[] = [];
-          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.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,
@@ -1098,17 +1027,6 @@ export default class ResultDataProvider {
           const stepRef = mentionedBaseFirstStep.get(baseKey) || 'Step ?';
           appendMentionedButNotLinked(baseKey, stepRef);
         }
-        if (traceCurrentTestCase) {
-          logger.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)
@@ -1146,21 +1064,23 @@ export default class ResultDataProvider {
         const validationStatus: 'Pass' | 'Fail' =
           mentionedButNotLinked || linkedButNotMentioned ? 'Fail' : 'Pass';
         if (validationStatus === 'Fail') diagnostics.failingRows += 1;
-        logger.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(', '),
-          })
-        );
+        if (traceCurrentTestCase) {
+          logger.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,
@@ -1309,7 +1229,7 @@ export default class ResultDataProvider {
   private createMewpCoverageRow(
     requirement: Pick<
       MewpL2RequirementFamily,
-      'workItemId' | 'requirementId' | 'title' | 'subSystem' | 'responsibility'
+      'workItemId' | 'requirementId' | 'title' | 'owner' | 'subSystem' | 'responsibility'
     >,
     runStatus: MewpRunStatus,
     bug: MewpCoverageBugCell,
@@ -1317,12 +1237,18 @@ export default class ResultDataProvider {
   ): MewpCoverageRow {
     const l2ReqIdNumeric = Number(requirement?.workItemId || 0);
     const l2ReqId = l2ReqIdNumeric > 0 ? String(l2ReqIdNumeric) : '';
+    const srNumber = this.normalizeMewpRequirementCodeWithSuffix(requirement?.requirementId || '');
     const l2ReqTitle = this.toMewpComparableText(requirement.title);
+    const reqName = this.deriveMewpRequirementDisplayName(srNumber, l2ReqTitle);
+    const l2Owner = this.toMewpComparableText(requirement.owner);
     const l2SubSystem = this.toMewpComparableText(requirement.subSystem);
 
     return {
       'L2 REQ ID': l2ReqId,
-      'L2 REQ Title': l2ReqTitle,
+      'SR #': srNumber,
+      'L2 REQ Title': reqName,
+      'L2 REQ Full Title': l2ReqTitle,
+      'L2 Owner': l2Owner,
       'L2 SubSystem': l2SubSystem,
       'L2 Run Status': runStatus,
       'Bug ID': Number.isFinite(Number(bug?.id)) && Number(bug?.id) > 0 ? Number(bug?.id) : '',
@@ -1335,6 +1261,20 @@ export default class ResultDataProvider {
     };
   }
 
+  private deriveMewpRequirementDisplayName(requirementCode: string, title: string): string {
+    const normalizedTitle = this.toMewpComparableText(title);
+    if (!normalizedTitle) return '';
+
+    const normalizedCode = this.normalizeMewpRequirementCodeWithSuffix(requirementCode || '');
+    if (!normalizedCode) return normalizedTitle;
+
+    const escapedCode = normalizedCode.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const codePrefixPattern = new RegExp(`^${escapedCode}(?:\\s*[:\\-–—]\\s*|\\s+)`, 'i');
+    const withoutCodePrefix = normalizedTitle.replace(codePrefixPattern, '').trim();
+    if (!withoutCodePrefix) return normalizedTitle;
+    return withoutCodePrefix;
+  }
+
   private createEmptyMewpCoverageBugCell(): MewpCoverageBugCell {
     return { id: '' as '', title: '', responsibility: '' };
   }
@@ -1655,14 +1595,17 @@ export default class ResultDataProvider {
   }
 
   private buildRequirementSapWbsByBaseKey(
-    requirements: Array<Pick<MewpL2RequirementWorkItem, 'baseKey' | 'responsibility'>>
+    requirements: Array<Pick<MewpL2RequirementWorkItem, 'baseKey' | 'owner' | 'responsibility'>>
   ): Map<string, string> {
     const out = new Map<string, string>();
     for (const requirement of requirements || []) {
       const baseKey = String(requirement?.baseKey || '').trim();
       if (!baseKey) continue;
 
-      const normalized = this.resolveMewpResponsibility(this.toMewpComparableText(requirement?.responsibility));
+      const rawOwner = this.toMewpComparableText(requirement?.owner);
+      const normalized =
+        this.resolveMewpResponsibility(rawOwner) ||
+        this.resolveMewpResponsibility(this.toMewpComparableText(requirement?.responsibility));
       if (!normalized) continue;
 
       const existing = out.get(baseKey) || '';
@@ -1812,6 +1755,81 @@ export default class ResultDataProvider {
     return map;
   }
 
+  private async enrichMewpTestCaseMapsFromLatestWorkItems(
+    projectName: string,
+    testCaseIds: number[],
+    stepsXmlByTestCase: Map<number, string>,
+    testCaseTitleMap: Map<number, string>,
+    testCaseDescriptionMap: Map<number, string>
+  ): Promise<{ stepsLoadedFromLatest: number; titleLoadedFromLatest: number; descriptionLoadedFromLatest: number }> {
+    const uniqueIds = [...new Set(testCaseIds)]
+      .map((id) => Number(id))
+      .filter((id) => Number.isFinite(id) && id > 0);
+
+    if (uniqueIds.length === 0) {
+      return {
+        stepsLoadedFromLatest: 0,
+        titleLoadedFromLatest: 0,
+        descriptionLoadedFromLatest: 0,
+      };
+    }
+
+    let stepsLoadedFromLatest = 0;
+    let titleLoadedFromLatest = 0;
+    let descriptionLoadedFromLatest = 0;
+
+    try {
+      const latestWorkItems = await this.fetchWorkItemsByIds(projectName, uniqueIds, false);
+      for (const workItem of latestWorkItems || []) {
+        const id = Number(workItem?.id || 0);
+        if (!Number.isFinite(id) || id <= 0) continue;
+
+        const fields = workItem?.fields || {};
+        const latestStepsXml = this.extractStepsXmlFromFieldsMap(fields);
+        if (latestStepsXml) {
+          const previous = String(stepsXmlByTestCase.get(id) || '');
+          if (previous !== latestStepsXml) {
+            stepsLoadedFromLatest += 1;
+          }
+          stepsXmlByTestCase.set(id, latestStepsXml);
+        }
+
+        const latestTitle = this.toMewpComparableText(
+          this.getFieldValueByName(fields, 'System.Title') ?? this.getFieldValueByName(fields, 'Title')
+        );
+        if (latestTitle) {
+          const previous = String(testCaseTitleMap.get(id) || '');
+          if (previous !== latestTitle) {
+            titleLoadedFromLatest += 1;
+          }
+          testCaseTitleMap.set(id, latestTitle);
+        }
+
+        const latestDescription = this.toMewpComparableText(
+          this.getFieldValueByName(fields, 'System.Description') ??
+            this.getFieldValueByName(fields, 'Description')
+        );
+        if (latestDescription) {
+          const previous = String(testCaseDescriptionMap.get(id) || '');
+          if (previous !== latestDescription) {
+            descriptionLoadedFromLatest += 1;
+          }
+          testCaseDescriptionMap.set(id, latestDescription);
+        }
+      }
+    } catch (error: any) {
+      logger.warn(
+        `MEWP internal validation: failed to load latest test-case fields: ${error?.message || error}`
+      );
+    }
+
+    return {
+      stepsLoadedFromLatest,
+      titleLoadedFromLatest,
+      descriptionLoadedFromLatest,
+    };
+  }
+
   private extractMewpTestCaseId(runResult: any): number {
     const testCaseId = Number(runResult?.testCaseId || runResult?.testCase?.id || 0);
     return Number.isFinite(testCaseId) ? testCaseId : 0;
@@ -2299,6 +2317,7 @@ export default class ResultDataProvider {
         requirementId,
         baseKey: this.toRequirementKey(requirementId),
         title: this.toMewpComparableText(fields?.['System.Title'] || wi?.title),
+        owner: this.deriveMewpRequirementOwner(fields),
         subSystem: this.deriveMewpSubSystem(fields),
         responsibility: this.deriveMewpResponsibility(fields),
         linkedTestCaseIds: this.extractLinkedTestCaseIdsFromRequirement(wi?.relations || []),
@@ -2348,6 +2367,7 @@ export default class ResultDataProvider {
       if (areaPath.includes('\\customer requirements\\level 2')) score += 3;
       if (!areaPath.includes('\\mop')) score += 2;
       if (String(item?.title || '').trim()) score += 1;
+      if (String(item?.owner || '').trim()) score += 1;
       if (String(item?.subSystem || '').trim()) score += 1;
       if (String(item?.responsibility || '').trim()) score += 1;
       return score;
@@ -2384,6 +2404,7 @@ export default class ResultDataProvider {
         requirementId: String(family?.representative?.requirementId || baseKey),
         baseKey,
         title: String(family?.representative?.title || ''),
+        owner: String(family?.representative?.owner || ''),
         subSystem: String(family?.representative?.subSystem || ''),
         responsibility: String(family?.representative?.responsibility || ''),
         linkedTestCaseIds: [...family.linkedTestCaseIds].sort((a, b) => a - b),
@@ -2835,6 +2856,24 @@ export default class ResultDataProvider {
     return '';
   }
 
+  // L2 owner is sourced only from requirement SAPWBS fields.
+  private deriveMewpRequirementOwner(fields: Record<string, any>): string {
+    const directCandidates = [fields?.['Custom.SAPWBS'], fields?.['SAPWBS']];
+    for (const candidate of directCandidates) {
+      const normalized = this.toMewpComparableText(candidate);
+      if (normalized) return normalized;
+    }
+
+    for (const [key, value] of Object.entries(fields || {})) {
+      const normalizedKey = String(key || '').toLowerCase();
+      if (!normalizedKey.includes('sapwbs')) continue;
+      const normalizedValue = this.toMewpComparableText(value);
+      if (normalizedValue) return normalizedValue;
+    }
+
+    return '';
+  }
+
   // Test-case responsibility must come from test-case path context (not SAPWBS).
   private deriveMewpTestCaseResponsibility(fields: Record<string, any>): string {
     const areaPathCandidates = [

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

@@ -1126,6 +1126,62 @@ describe('ResultDataProvider', () => {
   });
 
   describe('getMewpL2CoverageFlatResults', () => {
+    it('should split SR prefix into SR # + L2 REQ Title while preserving full title', () => {
+      const row = (resultDataProvider as any).createMewpCoverageRow(
+        {
+          workItemId: 5054,
+          requirementId: 'SR0054',
+          title: 'SR0054 - Engine startup coverage',
+          owner: 'ESUK',
+          subSystem: 'Propulsion',
+          responsibility: 'ESUK',
+        },
+        'Pass',
+        { id: '', title: '', responsibility: '' },
+        { l3Id: '', l3Title: '', l4Id: '', l4Title: '' }
+      );
+
+      expect(row).toEqual(
+        expect.objectContaining({
+          'L2 REQ ID': '5054',
+          'SR #': 'SR0054',
+          'L2 REQ Title': 'Engine startup coverage',
+          'L2 REQ Full Title': 'SR0054 - Engine startup coverage',
+          'L2 Owner': 'ESUK',
+          'L2 SubSystem': 'Propulsion',
+        })
+      );
+    });
+
+    it('should keep full title when title is only the SR token', () => {
+      const row = (resultDataProvider as any).createMewpCoverageRow(
+        {
+          workItemId: 9999,
+          requirementId: 'SR9999',
+          title: 'SR9999',
+          owner: 'IL',
+          subSystem: '',
+          responsibility: 'IL',
+        },
+        'Not Run',
+        { id: '', title: '', responsibility: '' },
+        { l3Id: '', l3Title: '', l4Id: '', l4Title: '' }
+      );
+
+      expect(row['L2 REQ Title']).toBe('SR9999');
+      expect(row['L2 REQ Full Title']).toBe('SR9999');
+      expect(row['L2 Owner']).toBe('IL');
+    });
+
+    it('should resolve L2 run status precedence: Fail > Not Run > Pass', () => {
+      const resolve = (resultDataProvider as any).resolveMewpL2RunStatus.bind(resultDataProvider as any);
+
+      expect(resolve({ passed: 2, failed: 1, notRun: 3, hasAnyTestCase: true })).toBe('Fail');
+      expect(resolve({ passed: 5, failed: 0, notRun: 1, hasAnyTestCase: true })).toBe('Not Run');
+      expect(resolve({ passed: 1, failed: 0, notRun: 0, hasAnyTestCase: true })).toBe('Pass');
+      expect(resolve({ passed: 0, failed: 0, notRun: 0, hasAnyTestCase: true })).toBe('Not Run');
+    });
+
     it('should fetch MEWP scoped test data from selected suites', async () => {
       jest.spyOn(resultDataProvider as any, 'fetchTestPlanName').mockResolvedValueOnce('Plan A');
       const scopedSpy = jest
@@ -1234,7 +1290,7 @@ describe('ResultDataProvider', () => {
       expect(result).toEqual(
         expect.objectContaining({
           sheetName: expect.stringContaining('MEWP L2 Coverage'),
-          columnOrder: expect.arrayContaining(['L2 REQ ID', 'L2 REQ Title', 'L2 Run Status']),
+          columnOrder: expect.arrayContaining(['L2 REQ ID', 'SR #', 'L2 REQ Title', 'L2 Owner', 'L2 Run Status']),
         })
       );
 
@@ -3449,6 +3505,100 @@ describe('ResultDataProvider', () => {
         })
       );
     });
+
+    it('should prefer latest test-case revision fields (title/description/steps) in internal validation flow', async () => {
+      jest.spyOn(resultDataProvider as any, 'fetchTestPlanName').mockResolvedValueOnce('Plan A');
+      jest.spyOn(resultDataProvider as any, 'fetchMewpScopedTestData').mockResolvedValueOnce([
+        {
+          testPointsItems: [{ testCaseId: 777, testCaseName: 'TC 777 (snapshot)' }],
+          testCasesItems: [
+            {
+              workItem: {
+                id: 777,
+                workItemFields: [
+                  { key: 'System.Title', value: 'TC 777 (snapshot title)' },
+                  {
+                    key: 'Microsoft.VSTS.TCM.Steps',
+                    value:
+                      '<steps><step id="2" type="ActionStep"><parameterizedString isformatted="true">Action</parameterizedString><parameterizedString isformatted="true">SR0001</parameterizedString></step></steps>',
+                  },
+                  { key: 'System.Description', value: '<p>Snapshot description</p>' },
+                ],
+              },
+            },
+          ],
+        },
+      ]);
+      jest.spyOn(resultDataProvider as any, 'fetchMewpL2Requirements').mockResolvedValueOnce([
+        {
+          workItemId: 9777,
+          requirementId: 'SR7777',
+          baseKey: 'SR7777',
+          title: 'Req 7777',
+          responsibility: 'ESUK',
+          linkedTestCaseIds: [777],
+          areaPath: 'MEWP\\Customer Requirements\\Level 2',
+        },
+      ]);
+      jest.spyOn(resultDataProvider as any, 'buildLinkedRequirementsByTestCase').mockResolvedValueOnce(
+        new Map([
+          [
+            777,
+            {
+              baseKeys: new Set(['SR7777']),
+              fullCodes: new Set(['SR7777']),
+            },
+          ],
+        ])
+      );
+      const fetchWorkItemsByIdsSpy = jest
+        .spyOn(resultDataProvider as any, 'fetchWorkItemsByIds')
+        .mockResolvedValueOnce([
+          {
+            id: 777,
+            fields: {
+              'System.Title': 'TC 777 (latest title)',
+              'System.Description':
+                '<p><b><u>Trial specific assumptions, constraints, dependencies and requirements</u></b></p><p>SR7777</p>',
+              'Microsoft.VSTS.TCM.Steps':
+                '<steps><step id="2" type="ActionStep"><parameterizedString isformatted="true">Action</parameterizedString><parameterizedString isformatted="true">SR7777</parameterizedString></step></steps>',
+            },
+          },
+        ]);
+      jest.spyOn((resultDataProvider as any).testStepParserHelper, 'parseTestSteps').mockImplementation(
+        async (...args: any[]) => [
+          {
+            stepId: '1',
+            stepPosition: '1',
+            action: 'Action',
+            expected: String(args?.[0] || '').includes('SR7777') ? 'SR7777' : 'SR0001',
+            isSharedStepTitle: false,
+          },
+        ]
+      );
+
+      const result = await (resultDataProvider as any).getMewpInternalValidationFlatResults(
+        '123',
+        mockProjectName,
+        [1]
+      );
+
+      expect(fetchWorkItemsByIdsSpy).toHaveBeenCalledWith(mockProjectName, [777], false);
+      expect((resultDataProvider as any).testStepParserHelper.parseTestSteps).toHaveBeenCalledWith(
+        expect.stringContaining('SR7777'),
+        expect.any(Map)
+      );
+      expect(result.rows).toHaveLength(1);
+      expect(result.rows[0]).toEqual(
+        expect.objectContaining({
+          'Test Case ID': 777,
+          'Test Case Title': 'TC 777 (latest title)',
+          'Mentioned but Not Linked': '',
+          'Linked but Not Mentioned': '',
+          'Validation Status': 'Pass',
+        })
+      );
+    });
   });
 
   describe('buildLinkedRequirementsByTestCase', () => {