@elisra-devops/docgen-data-provider 1.79.0 → 1.81.0

package/src/modules/ResultDataProvider.ts

@@ -17,7 +17,7 @@ import type {
   MewpInternalValidationRow,
   MewpL2RequirementFamily,
   MewpL2RequirementWorkItem,
-  MewpL3L4Link,
+  MewpL3L4Pair,
   MewpLinkedRequirementsByTestCase,
   MewpRequirementIndex,
   MewpRunStatus,
@@ -472,6 +472,11 @@ export default class ResultDataProvider {
         allRequirements,
         scopedRequirementKeys?.size ? scopedRequirementKeys : undefined
       );
+      const l2ToLinkedL1BaseKeys = await this.buildMewpL2ToLinkedL1BaseKeys(
+        allRequirements,
+        projectName,
+        testData
+      );
       const requirementSapWbsByBaseKey = this.buildRequirementSapWbsByBaseKey(allRequirements);
       const externalBugsByTestCase = await this.loadExternalBugsByTestCase(options?.externalBugsFile);
       const externalL3L4ByBaseKey = await this.loadExternalL3L4ByBaseKey(
@@ -523,6 +528,10 @@ export default class ResultDataProvider {
           sheetName: this.buildMewpCoverageSheetName(planName, testPlanId),
         };
       }
+      const externalJoinKeysByL2 = this.buildMewpExternalJoinKeysByL2Requirement(
+        requirements,
+        l2ToLinkedL1BaseKeys
+      );
 
       const requirementIndex: MewpRequirementIndex = new Map();
       const observedTestCaseIdsByRequirement = new Map<string, Set<number>>();
@@ -601,8 +610,16 @@ export default class ResultDataProvider {
       const requirementBaseKeys = new Set<string>(
         requirements.map((item) => String(item?.baseKey || '').trim()).filter((item) => !!item)
       );
+      const externalJoinKeyUniverse = new Set<string>();
+      for (const keySet of externalJoinKeysByL2.values()) {
+        for (const key of keySet) {
+          if (key) externalJoinKeyUniverse.add(key);
+        }
+      }
       const externalL3L4BaseKeys = new Set<string>([...externalL3L4ByBaseKey.keys()]);
-      const externalL3L4OverlapKeys = [...externalL3L4BaseKeys].filter((key) => requirementBaseKeys.has(key));
+      const externalL3L4OverlapKeys = [...externalL3L4BaseKeys].filter((key) =>
+        externalJoinKeyUniverse.has(key)
+      );
       const failedRequirementBaseKeys = new Set<string>();
       const failedTestCaseIds = new Set<number>();
       for (const [requirementBaseKey, byTestCase] of requirementIndex.entries()) {
@@ -625,13 +642,14 @@ export default class ResultDataProvider {
         }
       }
       const externalBugRequirementOverlap = [...externalBugBaseKeys].filter((key) =>
-        requirementBaseKeys.has(key)
+        externalJoinKeyUniverse.has(key)
       );
       const externalBugFailedRequirementOverlap = [...externalBugBaseKeys].filter((key) =>
-        failedRequirementBaseKeys.has(key)
+        externalJoinKeyUniverse.has(key)
       );
       logger.info(
         `MEWP coverage join diagnostics: requirementBaseKeys=${requirementBaseKeys.size} ` +
+          `externalJoinKeys=${externalJoinKeyUniverse.size} ` +
           `failedRequirementBaseKeys=${failedRequirementBaseKeys.size} failedTestCases=${failedTestCaseIds.size}; ` +
           `externalL3L4BaseKeys=${externalL3L4BaseKeys.size} externalL3L4Overlap=${externalL3L4OverlapKeys.length}; ` +
           `externalBugTestCases=${externalBugTestCaseIds.size} externalBugFailedTestCaseOverlap=${externalBugFailedTestCaseOverlap.length}; ` +
@@ -640,18 +658,22 @@ export default class ResultDataProvider {
       );
       if (externalL3L4BaseKeys.size > 0 && externalL3L4OverlapKeys.length === 0) {
         const sampleReq = [...requirementBaseKeys].slice(0, 5);
+        const sampleJoin = [...externalJoinKeyUniverse].slice(0, 5);
         const sampleExt = [...externalL3L4BaseKeys].slice(0, 5);
         logger.warn(
           `MEWP coverage join diagnostics: no L3/L4 key overlap found. ` +
-            `sampleRequirementKeys=${sampleReq.join(', ')} sampleExternalL3L4Keys=${sampleExt.join(', ')}`
+            `sampleRequirementKeys=${sampleReq.join(', ')} sampleJoinKeys=${sampleJoin.join(', ')} ` +
+            `sampleExternalL3L4Keys=${sampleExt.join(', ')}`
         );
       }
       if (externalBugBaseKeys.size > 0 && externalBugRequirementOverlap.length === 0) {
         const sampleReq = [...requirementBaseKeys].slice(0, 5);
+        const sampleJoin = [...externalJoinKeyUniverse].slice(0, 5);
         const sampleExt = [...externalBugBaseKeys].slice(0, 5);
         logger.warn(
           `MEWP coverage join diagnostics: no bug requirement-key overlap found. ` +
-            `sampleRequirementKeys=${sampleReq.join(', ')} sampleExternalBugKeys=${sampleExt.join(', ')}`
+            `sampleRequirementKeys=${sampleReq.join(', ')} sampleJoinKeys=${sampleJoin.join(', ')} ` +
+            `sampleExternalBugKeys=${sampleExt.join(', ')}`
         );
       }
       if (externalBugTestCaseIds.size > 0 && externalBugFailedTestCaseOverlap.length === 0) {
@@ -667,7 +689,8 @@ export default class ResultDataProvider {
         observedTestCaseIdsByRequirement,
         linkedRequirementsByTestCase,
         externalL3L4ByBaseKey,
-        externalBugsByTestCase
+        externalBugsByTestCase,
+        externalJoinKeysByL2
       );
       const coverageRowStats = rows.reduce(
         (acc, row) => {
@@ -757,14 +780,26 @@ export default class ResultDataProvider {
       }
 
       const validL2BaseKeys = new Set<string>([...requirementFamilies.keys()]);
+      const diagnostics = {
+        totalTestCases: 0,
+        totalParsedSteps: 0,
+        totalStepsWithMentions: 0,
+        totalMentionedCustomerIds: 0,
+        testCasesWithoutMentionedCustomerIds: 0,
+        failingRows: 0,
+      };
 
       for (const testCaseId of [...allTestCaseIds].sort((a, b) => a - b)) {
+        diagnostics.totalTestCases += 1;
         const stepsXml = stepsXmlByTestCase.get(testCaseId) || '';
         const parsedSteps =
           stepsXml && String(stepsXml).trim() !== ''
             ? await this.testStepParserHelper.parseTestSteps(stepsXml, new Map<number, number>())
             : [];
+        const executableSteps = parsedSteps.filter((step) => !step?.isSharedStepTitle);
+        diagnostics.totalParsedSteps += executableSteps.length;
         const mentionEntries = this.extractRequirementMentionsFromExpectedSteps(parsedSteps, true);
+        diagnostics.totalStepsWithMentions += mentionEntries.length;
         const mentionedL2Only = new Set<string>();
         const mentionedCodeFirstStep = new Map<string, string>();
         const mentionedBaseFirstStep = new Map<string, string>();
@@ -787,6 +822,10 @@ export default class ResultDataProvider {
             }
           }
         }
+        diagnostics.totalMentionedCustomerIds += mentionedL2Only.size;
+        if (mentionedL2Only.size === 0) {
+          diagnostics.testCasesWithoutMentionedCustomerIds += 1;
+        }
 
         const mentionedBaseKeys = new Set<string>(
           [...mentionedL2Only].map((code) => this.toRequirementKey(code)).filter((code) => !!code)
@@ -874,6 +913,15 @@ export default class ResultDataProvider {
         const linkedButNotMentioned = sortedExtraLinked.join('; ');
         const validationStatus: 'Pass' | 'Fail' =
           mentionedButNotLinked || linkedButNotMentioned ? 'Fail' : 'Pass';
+        if (validationStatus === 'Fail') diagnostics.failingRows += 1;
+        logger.debug(
+          `MEWP internal validation parse diagnostics: ` +
+            `testCaseId=${testCaseId} parsedSteps=${executableSteps.length} ` +
+            `stepsWithMentions=${mentionEntries.length} customerIdsFound=${mentionedL2Only.size} ` +
+            `linkedRequirements=${linkedFullCodes.size} mentionedButNotLinked=${sortedMissingMentioned.length + sortedMissingFamily.length} ` +
+            `linkedButNotMentioned=${sortedExtraLinked.length} status=${validationStatus} ` +
+            `customerIdSample='${[...mentionedL2Only].slice(0, 5).join(', ')}'`
+        );
 
         rows.push({
           'Test Case ID': testCaseId,
@@ -883,6 +931,13 @@ export default class ResultDataProvider {
           'Validation Status': validationStatus,
         });
       }
+      logger.info(
+        `MEWP internal validation summary: testCases=${diagnostics.totalTestCases} ` +
+          `parsedSteps=${diagnostics.totalParsedSteps} stepsWithMentions=${diagnostics.totalStepsWithMentions} ` +
+          `totalCustomerIdsFound=${diagnostics.totalMentionedCustomerIds} ` +
+          `testCasesWithoutCustomerIds=${diagnostics.testCasesWithoutMentionedCustomerIds} ` +
+          `failingRows=${diagnostics.failingRows}`
+      );
 
       return {
         sheetName: this.buildInternalValidationSheetName(planName, testPlanId),
@@ -1035,23 +1090,35 @@ export default class ResultDataProvider {
     return { l3Id: '', l3Title: '', l4Id: '', l4Title: '' };
   }
 
-  private buildMewpCoverageL3L4Rows(links: MewpL3L4Link[]): MewpCoverageL3L4Cell[] {
-    const sorted = [...(links || [])].sort((a, b) => {
-      if (a.level !== b.level) return a.level === 'L3' ? -1 : 1;
-      return String(a.id || '').localeCompare(String(b.id || ''));
-    });
+  private buildMewpCoverageL3L4Rows(pairs: MewpL3L4Pair[]): MewpCoverageL3L4Cell[] {
+    const deduped = new Map<string, MewpCoverageL3L4Cell>();
+    for (const pair of pairs || []) {
+      const l3Id = String(pair?.l3Id || '').trim();
+      const l3Title = String(pair?.l3Title || '').trim();
+      const l4Id = String(pair?.l4Id || '').trim();
+      const l4Title = String(pair?.l4Title || '').trim();
+      if (!l3Id && !l4Id) continue;
+
+      const key = `${l3Id}|${l4Id}`;
+      const existing = deduped.get(key);
+      if (!existing) {
+        deduped.set(key, { l3Id, l3Title, l4Id, l4Title });
+        continue;
+      }
 
-    const rows: MewpCoverageL3L4Cell[] = [];
-    for (const item of sorted) {
-      const isL3 = item.level === 'L3';
-      rows.push({
-        l3Id: isL3 ? String(item?.id || '').trim() : '',
-        l3Title: isL3 ? String(item?.title || '').trim() : '',
-        l4Id: isL3 ? '' : String(item?.id || '').trim(),
-        l4Title: isL3 ? '' : String(item?.title || '').trim(),
+      deduped.set(key, {
+        l3Id: existing.l3Id || l3Id,
+        l3Title: existing.l3Title || l3Title,
+        l4Id: existing.l4Id || l4Id,
+        l4Title: existing.l4Title || l4Title,
       });
     }
-    return rows;
+
+    return [...deduped.values()].sort((a, b) => {
+      const l3Compare = String(a?.l3Id || '').localeCompare(String(b?.l3Id || ''));
+      if (l3Compare !== 0) return l3Compare;
+      return String(a?.l4Id || '').localeCompare(String(b?.l4Id || ''));
+    });
   }
 
   private buildMewpCoverageRows(
@@ -1059,13 +1126,16 @@ export default class ResultDataProvider {
     requirementIndex: MewpRequirementIndex,
     observedTestCaseIdsByRequirement: Map<string, Set<number>>,
     linkedRequirementsByTestCase: MewpLinkedRequirementsByTestCase,
-    l3l4ByBaseKey: Map<string, MewpL3L4Link[]>,
-    externalBugsByTestCase: Map<number, MewpBugLink[]>
+    l3l4ByBaseKey: Map<string, MewpL3L4Pair[]>,
+    externalBugsByTestCase: Map<number, MewpBugLink[]>,
+    externalJoinKeysByL2?: Map<string, Set<string>>
   ): MewpCoverageRow[] {
     const rows: MewpCoverageRow[] = [];
     const linkedByRequirement = this.invertBaseRequirementLinks(linkedRequirementsByTestCase);
+    const joinKeysByRequirement = externalJoinKeysByL2 || new Map<string, Set<string>>();
     for (const requirement of requirements) {
       const key = String(requirement?.baseKey || this.toRequirementKey(requirement.requirementId) || '').trim();
+      const externalJoinKeys = joinKeysByRequirement.get(key) || new Set<string>([key]);
       const linkedTestCaseIds = (requirement?.linkedTestCaseIds || []).filter(
         (id) => Number.isFinite(id) && Number(id) > 0
       );
@@ -1095,7 +1165,7 @@ export default class ResultDataProvider {
           const externalBugs = externalBugsByTestCase.get(testCaseId) || [];
           for (const bug of externalBugs) {
             const bugBaseKey = String(bug?.requirementBaseKey || '').trim();
-            if (bugBaseKey && bugBaseKey !== key) continue;
+            if (bugBaseKey && !externalJoinKeys.has(bugBaseKey)) continue;
             const bugId = Number(bug?.id || 0);
             if (!Number.isFinite(bugId) || bugId <= 0) continue;
             aggregatedBugs.set(bugId, {
@@ -1120,44 +1190,22 @@ export default class ResultDataProvider {
         runStatus === 'Fail'
           ? Array.from(aggregatedBugs.values()).sort((a, b) => a.id - b.id)
           : [];
-      const l3l4ForRows = [...(l3l4ByBaseKey.get(key) || [])];
+      const l3l4ForRows = [...externalJoinKeys].flatMap((joinKey) => l3l4ByBaseKey.get(joinKey) || []);
 
-      const bugRows: MewpCoverageBugCell[] =
-        bugsForRows.length > 0
-          ? bugsForRows
-          : [];
+      const bugRows: MewpCoverageBugCell[] = bugsForRows.map((bug) => ({
+        id: Number.isFinite(Number(bug?.id)) && Number(bug?.id) > 0 ? Number(bug?.id) : '',
+        title: String(bug?.title || '').trim(),
+        responsibility: String(bug?.responsibility || '').trim(),
+      }));
       const l3l4Rows: MewpCoverageL3L4Cell[] = this.buildMewpCoverageL3L4Rows(l3l4ForRows);
-
-      if (bugRows.length === 0 && l3l4Rows.length === 0) {
-        rows.push(
-          this.createMewpCoverageRow(
-            requirement,
-            runStatus,
-            this.createEmptyMewpCoverageBugCell(),
-            this.createEmptyMewpCoverageL3L4Cell()
-          )
-        );
-        continue;
-      }
-
-      for (const bug of bugRows) {
+      const rowCount = Math.max(bugRows.length, l3l4Rows.length, 1);
+      for (let index = 0; index < rowCount; index += 1) {
         rows.push(
           this.createMewpCoverageRow(
             requirement,
             runStatus,
-            bug,
-            this.createEmptyMewpCoverageL3L4Cell()
-          )
-        );
-      }
-
-      for (const linkedL3L4 of l3l4Rows) {
-        rows.push(
-          this.createMewpCoverageRow(
-            requirement,
-            runStatus,
-            this.createEmptyMewpCoverageBugCell(),
-            linkedL3L4
+            bugRows[index] || this.createEmptyMewpCoverageBugCell(),
+            l3l4Rows[index] || this.createEmptyMewpCoverageL3L4Cell()
           )
         );
       }
@@ -1348,7 +1396,7 @@ export default class ResultDataProvider {
   private async loadExternalL3L4ByBaseKey(
     externalL3L4File: MewpExternalFileRef | null | undefined,
     requirementSapWbsByBaseKey: Map<string, string> = new Map<string, string>()
-  ): Promise<Map<string, MewpL3L4Link[]>> {
+  ): Promise<Map<string, MewpL3L4Pair[]>> {
     return this.mewpExternalIngestionUtils.loadExternalL3L4ByBaseKey(externalL3L4File, {
       toComparableText: (value) => this.toMewpComparableText(value),
       toRequirementKey: (value) => this.toRequirementKey(value),
@@ -1884,6 +1932,123 @@ export default class ResultDataProvider {
       .sort((a, b) => String(a.requirementId).localeCompare(String(b.requirementId)));
   }
 
+  private async buildMewpL2ToLinkedL1BaseKeys(
+    requirements: MewpL2RequirementWorkItem[],
+    projectName: string,
+    testData: any[]
+  ): Promise<Map<string, Set<string>>> {
+    const out = new Map<string, Set<string>>();
+    const relatedIds = new Set<number>();
+    const linkedTestCaseIdsByL2 = new Map<string, Set<number>>();
+    const testCaseTitleMap = this.buildMewpTestCaseTitleMap(testData);
+
+    for (const requirement of requirements || []) {
+      const l2BaseKey = String(requirement?.baseKey || '').trim();
+      if (!l2BaseKey) continue;
+      if (!out.has(l2BaseKey)) out.set(l2BaseKey, new Set<string>());
+      if (!linkedTestCaseIdsByL2.has(l2BaseKey)) linkedTestCaseIdsByL2.set(l2BaseKey, new Set<number>());
+      for (const testCaseId of requirement?.linkedTestCaseIds || []) {
+        const numeric = Number(testCaseId);
+        if (Number.isFinite(numeric) && numeric > 0) {
+          linkedTestCaseIdsByL2.get(l2BaseKey)!.add(numeric);
+        }
+      }
+      for (const relatedId of requirement?.relatedWorkItemIds || []) {
+        const id = Number(relatedId);
+        if (Number.isFinite(id) && id > 0) relatedIds.add(id);
+      }
+    }
+
+    let titleDerivedCount = 0;
+    for (const [l2BaseKey, testCaseIds] of linkedTestCaseIdsByL2.entries()) {
+      const targetSet = out.get(l2BaseKey) || new Set<string>();
+      for (const testCaseId of testCaseIds) {
+        const title = String(testCaseTitleMap.get(testCaseId) || '').trim();
+        if (!title) continue;
+        const fromTitleCodes = this.extractRequirementCodesFromExpectedText(title, false);
+        if (fromTitleCodes.size > 0) {
+          for (const code of fromTitleCodes) {
+            const normalized = this.toRequirementKey(code);
+            if (normalized) targetSet.add(normalized);
+          }
+        } else {
+          const normalized = this.toRequirementKey(title);
+          if (normalized) targetSet.add(normalized);
+        }
+      }
+      if (targetSet.size > 0) {
+        titleDerivedCount += 1;
+      }
+      out.set(l2BaseKey, targetSet);
+    }
+
+    if (relatedIds.size === 0) {
+      const linkedL1Count = [...out.values()].reduce((sum, set) => sum + set.size, 0);
+      logger.info(
+        `MEWP L2->L1 mapping summary: l2Families=${out.size} ` +
+          `fromTitle=${titleDerivedCount} fallbackFromLinkedL1=0 linkedL1Keys=${linkedL1Count}`
+      );
+      return out;
+    }
+
+    const relatedWorkItems = await this.fetchWorkItemsByIds(projectName, [...relatedIds], false);
+    const l1BaseByWorkItemId = new Map<number, string>();
+    for (const workItem of relatedWorkItems || []) {
+      const workItemId = Number(workItem?.id || 0);
+      if (!Number.isFinite(workItemId) || workItemId <= 0) continue;
+      const fields = workItem?.fields || {};
+      const customerId = this.extractMewpRequirementIdentifier(fields);
+      const baseKey = this.toRequirementKey(customerId);
+      if (!baseKey) continue;
+      l1BaseByWorkItemId.set(workItemId, baseKey);
+    }
+
+    let linkedFallbackCount = 0;
+    for (const requirement of requirements || []) {
+      const l2BaseKey = String(requirement?.baseKey || '').trim();
+      if (!l2BaseKey) continue;
+      if (!out.has(l2BaseKey)) out.set(l2BaseKey, new Set<string>());
+      const targetSet = out.get(l2BaseKey)!;
+      if (targetSet.size > 0) {
+        continue;
+      }
+      for (const relatedId of requirement?.relatedWorkItemIds || []) {
+        const baseKey = l1BaseByWorkItemId.get(Number(relatedId));
+        if (baseKey) targetSet.add(baseKey);
+      }
+      if (targetSet.size > 0) {
+        linkedFallbackCount += 1;
+      }
+    }
+
+    const l2Families = out.size;
+    const withLinkedL1 = [...out.values()].filter((set) => set.size > 0).length;
+    const linkedL1Count = [...out.values()].reduce((sum, set) => sum + set.size, 0);
+    logger.info(
+      `MEWP L2->L1 mapping summary: l2Families=${l2Families} withLinkedL1=${withLinkedL1} ` +
+        `fromTitle=${titleDerivedCount} fallbackFromLinkedL1=${linkedFallbackCount} linkedL1Keys=${linkedL1Count}`
+    );
+    return out;
+  }
+
+  private buildMewpExternalJoinKeysByL2Requirement(
+    requirements: MewpL2RequirementFamily[],
+    l2ToLinkedL1BaseKeys: Map<string, Set<string>>
+  ): Map<string, Set<string>> {
+    const out = new Map<string, Set<string>>();
+    for (const requirement of requirements || []) {
+      const l2BaseKey = String(requirement?.baseKey || '').trim();
+      if (!l2BaseKey) continue;
+      const joinKeys = new Set<string>([l2BaseKey]);
+      for (const l1Key of l2ToLinkedL1BaseKeys.get(l2BaseKey) || []) {
+        const normalized = String(l1Key || '').trim();
+        if (normalized) joinKeys.add(normalized);
+      }
+      out.set(l2BaseKey, joinKeys);
+    }
+    return out;
+  }
+
   private buildRequirementFamilyMap(
     requirements: Array<Pick<MewpL2RequirementWorkItem, 'requirementId' | 'baseKey'>>,
     scopedRequirementKeys?: Set<string>

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

@@ -1341,7 +1341,7 @@ describe('ResultDataProvider', () => {
       expect(il).toBe('IL');
     });
 
-    it('should emit additive rows for bugs and L3/L4 links without bug duplication', () => {
+    it('should zip bug rows with L3/L4 pairs and avoid cross-product duplication', () => {
       const requirements = [
         {
           requirementId: 'SR5303',
@@ -1398,8 +1398,7 @@ describe('ResultDataProvider', () => {
         [
           'SR5303',
           [
-            { id: '9003', title: 'L3 9003', level: 'L3' as const },
-            { id: '9103', title: 'L4 9103', level: 'L4' as const },
+            { l3Id: '9003', l3Title: 'L3 9003', l4Id: '9103', l4Title: 'L4 9103' },
           ],
         ],
       ]);
@@ -1413,18 +1412,18 @@ describe('ResultDataProvider', () => {
         externalBugsByTestCase
       );
 
-      expect(rows).toHaveLength(4);
-      expect(rows.map((row: any) => row['Bug ID'])).toEqual([10003, 20003, '', '']);
-      expect(rows[2]).toEqual(
+      expect(rows).toHaveLength(2);
+      expect(rows.map((row: any) => row['Bug ID'])).toEqual([10003, 20003]);
+      expect(rows[0]).toEqual(
         expect.objectContaining({
           'L3 REQ ID': '9003',
-          'L4 REQ ID': '',
+          'L4 REQ ID': '9103',
         })
       );
-      expect(rows[3]).toEqual(
+      expect(rows[1]).toEqual(
         expect.objectContaining({
           'L3 REQ ID': '',
-          'L4 REQ ID': '9103',
+          'L4 REQ ID': '',
         })
       );
     });
@@ -2561,8 +2560,29 @@ describe('ResultDataProvider', () => {
 
       const map = await (resultDataProvider as any).loadExternalL3L4ByBaseKey(validL3L4Source);
       expect(map.get('SR0001')).toEqual([
-        { id: '7002', title: 'L3 Requirement', level: 'L3' },
-        { id: '7001', title: 'L4 From Level3 Column', level: 'L4' },
+        { l3Id: '', l3Title: '', l4Id: '7001', l4Title: 'L4 From Level3 Column' },
+        { l3Id: '7002', l3Title: 'L3 Requirement', l4Id: '', l4Title: '' },
+      ]);
+    });
+
+    it('should emit paired L3+L4 when AREA 34 is Level 4 and both level columns are present', async () => {
+      const mewpExternalTableUtils = (resultDataProvider as any).mewpExternalTableUtils;
+      jest.spyOn(mewpExternalTableUtils, 'loadExternalTableRows').mockResolvedValueOnce([
+        {
+          SR: 'SR0001',
+          'AREA 34': 'Level 4',
+          'TargetWorkItemId Level 3': '7401',
+          TargetTitleLevel3: 'L3 In Level4 Row',
+          'TargetStateLevel 3': 'Active',
+          'TargetWorkItemIdLevel 4': '8401',
+          TargetTitleLevel4: 'L4 In Level4 Row',
+          'TargetStateLevel 4': 'Active',
+        },
+      ]);
+
+      const map = await (resultDataProvider as any).loadExternalL3L4ByBaseKey(validL3L4Source);
+      expect(map.get('SR0001')).toEqual([
+        { l3Id: '7401', l3Title: 'L3 In Level4 Row', l4Id: '8401', l4Title: 'L4 In Level4 Row' },
       ]);
     });
 
@@ -2593,8 +2613,8 @@ describe('ResultDataProvider', () => {
 
       const map = await (resultDataProvider as any).loadExternalL3L4ByBaseKey(validL3L4Source);
       expect(map.get('SR0001')).toEqual([
-        { id: '7102', title: 'L3 IL', level: 'L3' },
-        { id: '7201', title: 'L4 IL', level: 'L4' },
+        { l3Id: '', l3Title: '', l4Id: '7201', l4Title: 'L4 IL' },
+        { l3Id: '7102', l3Title: 'L3 IL', l4Id: '', l4Title: '' },
       ]);
     });
 
@@ -2628,7 +2648,9 @@ describe('ResultDataProvider', () => {
       );
 
       expect(map.has('SR0001')).toBe(false);
-      expect(map.get('SR0002')).toEqual([{ id: '7302', title: 'L3 From IL Requirement', level: 'L3' }]);
+      expect(map.get('SR0002')).toEqual([
+        { l3Id: '7302', l3Title: 'L3 From IL Requirement', l4Id: '', l4Title: '' },
+      ]);
     });
 
     it('should resolve bug responsibility from AreaPath when SAPWBS is empty', () => {