@elisra-devops/docgen-data-provider 1.73.0 → 1.75.0

package/src/modules/ResultDataProvider.ts

@@ -30,14 +30,14 @@ const pLimit = require('p-limit');
  */
 export default class ResultDataProvider {
   private static readonly MEWP_L2_COVERAGE_COLUMNS = [
-    'Customer Requirement',
-    'Requirement ID',
-    'Requirement Title',
-    'Responsibility',
-    'SAPWBS / Responsibility',
+    'Customer ID',
+    'Title (Customer name)',
+    'Responsibility - SAPWBS (ESUK/IL)',
+    'Test case id',
+    'Test case title',
     'Number of passed steps',
     'Number of failed steps',
-    'Number of steps not run',
+    'Number of not run tests',
   ];
 
   orgUrl: string = '';
@@ -414,26 +414,28 @@ export default class ResultDataProvider {
         };
       }
 
-      const requirementIndex = new Map<
-        string,
-        { passed: number; failed: number; notRun: number }
-      >();
+      const requirementIndex = new Map<string, Map<number, { passed: number; failed: number; notRun: number }>>();
+      const observedTestCaseIdsByRequirement = new Map<string, Set<number>>();
       const requirementKeys = new Set<string>();
       requirements.forEach((requirement) => {
         const key = this.toRequirementKey(requirement.requirementId);
         if (!key) return;
         requirementKeys.add(key);
-        if (!requirementIndex.has(key)) {
-          requirementIndex.set(key, { passed: 0, failed: 0, notRun: 0 });
-        }
       });
 
       const parsedDefinitionStepsByTestCase = new Map<number, TestSteps[]>();
       const testCaseStepsXmlMap = this.buildTestCaseStepsXmlMap(testData);
+      const testCaseTitleMap = this.buildMewpTestCaseTitleMap(testData);
 
       const runResults = await this.fetchAllResultDataTestReporter(testData, projectName, [], false, false);
       for (const runResult of runResults) {
-        const testCaseId = Number(runResult?.testCaseId);
+        const testCaseId = this.extractMewpTestCaseId(runResult);
+        const runTestCaseTitle = this.toMewpComparableText(
+          runResult?.testCase?.name || runResult?.testCaseName || runResult?.testCaseTitle
+        );
+        if (Number.isFinite(testCaseId) && testCaseId > 0 && runTestCaseTitle && !testCaseTitleMap.has(testCaseId)) {
+          testCaseTitleMap.set(testCaseId, runTestCaseTitle);
+        }
         const actionResults = Array.isArray(runResult?.iteration?.actionResults)
           ? runResult.iteration.actionResults
           : [];
@@ -447,8 +449,10 @@ export default class ResultDataProvider {
             this.accumulateRequirementCountsFromStepText(
               `${String(actionResult?.action || '')} ${String(actionResult?.expected || '')}`,
               stepStatus,
+              testCaseId,
               requirementKeys,
-              requirementIndex
+              requirementIndex,
+              observedTestCaseIdsByRequirement
             );
           }
           continue;
@@ -476,19 +480,20 @@ export default class ResultDataProvider {
           this.accumulateRequirementCountsFromStepText(
             `${String(step?.action || '')} ${String(step?.expected || '')}`,
             'notRun',
+            testCaseId,
             requirementKeys,
-            requirementIndex
+            requirementIndex,
+            observedTestCaseIdsByRequirement
           );
         }
       }
 
-      const rows: any[] = requirements.map((requirement) => {
-        const key = this.toRequirementKey(requirement.requirementId);
-        const summary = key && requirementIndex.has(key)
-          ? requirementIndex.get(key)!
-          : { passed: 0, failed: 0, notRun: 0 };
-        return this.createMewpCoverageRow(requirement, summary);
-      });
+      const rows = this.buildMewpCoverageRows(
+        requirements,
+        requirementIndex,
+        observedTestCaseIdsByRequirement,
+        testCaseTitleMap
+      );
 
       return {
         sheetName: this.buildMewpCoverageSheetName(planName, testPlanId),
@@ -550,23 +555,140 @@ export default class ResultDataProvider {
       title: string;
       responsibility: string;
     },
+    testCaseId: number | undefined,
+    testCaseTitle: string,
     stepSummary: { passed: number; failed: number; notRun: number }
   ) {
-    const requirementId = String(requirement.requirementId || '').trim();
-    const requirementTitle = String(requirement.title || '').trim();
-    const customerRequirement = [requirementId, requirementTitle].filter(Boolean).join(' - ');
-    const responsibility = String(requirement.responsibility || '').trim();
+    const customerId = this.formatMewpCustomerId(requirement.requirementId);
+    const customerTitle = this.toMewpComparableText(requirement.title);
+    const responsibility = this.toMewpComparableText(requirement.responsibility);
+    const safeTestCaseId = Number.isFinite(testCaseId) && Number(testCaseId) > 0 ? Number(testCaseId) : '';
 
     return {
-      'Customer Requirement': customerRequirement || requirementId || requirementTitle,
-      'Requirement ID': requirementId,
-      'Requirement Title': requirementTitle,
-      Responsibility: responsibility,
-      'SAPWBS / Responsibility': responsibility,
+      'Customer ID': customerId,
+      'Title (Customer name)': customerTitle,
+      'Responsibility - SAPWBS (ESUK/IL)': responsibility,
+      'Test case id': safeTestCaseId,
+      'Test case title': String(testCaseTitle || '').trim(),
       'Number of passed steps': Number.isFinite(stepSummary?.passed) ? stepSummary.passed : 0,
       'Number of failed steps': Number.isFinite(stepSummary?.failed) ? stepSummary.failed : 0,
-      'Number of steps not run': Number.isFinite(stepSummary?.notRun) ? stepSummary.notRun : 0,
+      'Number of not run tests': Number.isFinite(stepSummary?.notRun) ? stepSummary.notRun : 0,
+    };
+  }
+
+  private formatMewpCustomerId(rawValue: string): string {
+    const normalized = this.normalizeMewpRequirementCode(this.toMewpComparableText(rawValue));
+    if (normalized) return normalized;
+
+    const onlyDigits = String(rawValue || '').replace(/\D/g, '');
+    if (onlyDigits) return `SR${onlyDigits}`;
+    return '';
+  }
+
+  private buildMewpCoverageRows(
+    requirements: Array<{
+      requirementId: string;
+      title: string;
+      responsibility: string;
+      linkedTestCaseIds: number[];
+    }>,
+    requirementIndex: Map<string, Map<number, { passed: number; failed: number; notRun: number }>>,
+    observedTestCaseIdsByRequirement: Map<string, Set<number>>,
+    testCaseTitleMap: Map<number, string>
+  ): any[] {
+    const rows: any[] = [];
+    for (const requirement of requirements) {
+      const key = this.toRequirementKey(requirement.requirementId);
+      const linkedTestCaseIds = (requirement?.linkedTestCaseIds || []).filter(
+        (id) => Number.isFinite(id) && Number(id) > 0
+      );
+      const observedTestCaseIds = key
+        ? Array.from(observedTestCaseIdsByRequirement.get(key) || [])
+        : [];
+
+      const testCaseIds = Array.from(new Set<number>([...linkedTestCaseIds, ...observedTestCaseIds])).sort(
+        (a, b) => a - b
+      );
+
+      if (testCaseIds.length === 0) {
+        rows.push(
+          this.createMewpCoverageRow(requirement, undefined, '', {
+            passed: 0,
+            failed: 0,
+            notRun: 0,
+          })
+        );
+        continue;
+      }
+
+      for (const testCaseId of testCaseIds) {
+        const summary = key
+          ? requirementIndex.get(key)?.get(testCaseId) || { passed: 0, failed: 0, notRun: 0 }
+          : { passed: 0, failed: 0, notRun: 0 };
+        rows.push(
+          this.createMewpCoverageRow(
+            requirement,
+            testCaseId,
+            String(testCaseTitleMap.get(testCaseId) || ''),
+            summary
+          )
+        );
+      }
+    }
+
+    return rows;
+  }
+
+  private buildMewpTestCaseTitleMap(testData: any[]): Map<number, string> {
+    const map = new Map<number, string>();
+
+    const readTitleFromWorkItemFields = (workItemFields: any): string => {
+      if (!Array.isArray(workItemFields)) return '';
+      for (const field of workItemFields) {
+        const keyCandidates = [field?.key, field?.name, field?.referenceName, field?.id]
+          .map((item) => String(item || '').toLowerCase().trim());
+        const isTitleField =
+          keyCandidates.includes('system.title') || keyCandidates.includes('title');
+        if (!isTitleField) continue;
+        const value = this.toMewpComparableText(field?.value);
+        if (value) return value;
+      }
+      return '';
     };
+
+    for (const suite of testData || []) {
+      const testPointsItems = Array.isArray(suite?.testPointsItems) ? suite.testPointsItems : [];
+      for (const point of testPointsItems) {
+        const pointTestCaseId = Number(point?.testCaseId || point?.testCase?.id);
+        if (!Number.isFinite(pointTestCaseId) || pointTestCaseId <= 0 || map.has(pointTestCaseId)) continue;
+        const pointTitle = this.toMewpComparableText(point?.testCaseName || point?.testCase?.name);
+        if (pointTitle) map.set(pointTestCaseId, pointTitle);
+      }
+
+      const testCasesItems = Array.isArray(suite?.testCasesItems) ? suite.testCasesItems : [];
+      for (const testCase of testCasesItems) {
+        const id = Number(testCase?.workItem?.id || testCase?.testCaseId || testCase?.id);
+        if (!Number.isFinite(id) || id <= 0 || map.has(id)) continue;
+        const fromDirectFields = this.toMewpComparableText(
+          testCase?.testCaseName || testCase?.name || testCase?.workItem?.name
+        );
+        if (fromDirectFields) {
+          map.set(id, fromDirectFields);
+          continue;
+        }
+        const fromWorkItemField = readTitleFromWorkItemFields(testCase?.workItem?.workItemFields);
+        if (fromWorkItemField) {
+          map.set(id, fromWorkItemField);
+        }
+      }
+    }
+
+    return map;
+  }
+
+  private extractMewpTestCaseId(runResult: any): number {
+    const testCaseId = Number(runResult?.testCaseId || runResult?.testCase?.id || 0);
+    return Number.isFinite(testCaseId) ? testCaseId : 0;
   }
 
   private buildTestCaseStepsXmlMap(testData: any[]): Map<number, string> {
@@ -617,16 +739,30 @@ export default class ResultDataProvider {
   private accumulateRequirementCountsFromStepText(
     stepText: string,
     status: 'passed' | 'failed' | 'notRun',
+    testCaseId: number,
     requirementKeys: Set<string>,
-    counters: Map<string, { passed: number; failed: number; notRun: number }>
+    counters: Map<string, Map<number, { passed: number; failed: number; notRun: number }>>,
+    observedTestCaseIdsByRequirement: Map<string, Set<number>>
   ) {
+    if (!Number.isFinite(testCaseId) || testCaseId <= 0) return;
+
     const codes = this.extractRequirementCodesFromText(stepText);
     for (const code of codes) {
       if (requirementKeys.size > 0 && !requirementKeys.has(code)) continue;
       if (!counters.has(code)) {
-        counters.set(code, { passed: 0, failed: 0, notRun: 0 });
+        counters.set(code, new Map<number, { passed: number; failed: number; notRun: number }>());
+      }
+      const perTestCaseCounters = counters.get(code)!;
+      if (!perTestCaseCounters.has(testCaseId)) {
+        perTestCaseCounters.set(testCaseId, { passed: 0, failed: 0, notRun: 0 });
+      }
+
+      if (!observedTestCaseIdsByRequirement.has(code)) {
+        observedTestCaseIdsByRequirement.set(code, new Set<number>());
       }
-      const counter = counters.get(code)!;
+      observedTestCaseIdsByRequirement.get(code)!.add(testCaseId);
+
+      const counter = perTestCaseCounters.get(testCaseId)!;
       if (status === 'passed') counter.passed += 1;
       else if (status === 'failed') counter.failed += 1;
       else counter.notRun += 1;
@@ -713,7 +849,7 @@ ORDER BY [System.Id]`;
       return {
         workItemId: Number(wi?.id || 0),
         requirementId: this.extractMewpRequirementIdentifier(fields, Number(wi?.id || 0)),
-        title: String(fields['System.Title'] || ''),
+        title: this.toMewpComparableText(fields?.['System.Title'] || wi?.title),
         responsibility: this.deriveMewpResponsibility(fields),
         linkedTestCaseIds: this.extractLinkedTestCaseIdsFromRequirement(wi?.relations || []),
       };
@@ -823,10 +959,20 @@ ORDER BY [System.Id]`;
     const titleCode = this.normalizeMewpRequirementCode(title);
     if (titleCode) return titleCode;
 
-    return String(fallbackWorkItemId || '');
+    return fallbackWorkItemId ? `SR${fallbackWorkItemId}` : '';
   }
 
   private deriveMewpResponsibility(fields: Record<string, any>): string {
+    const explicitSapWbs = this.toMewpComparableText(fields?.['Custom.SAPWBS']);
+    const fromExplicitSapWbs = this.resolveMewpResponsibility(explicitSapWbs);
+    if (fromExplicitSapWbs) return fromExplicitSapWbs;
+    if (explicitSapWbs) return explicitSapWbs;
+
+    const explicitSapWbsByLabel = this.toMewpComparableText(fields?.['SAPWBS']);
+    const fromExplicitLabel = this.resolveMewpResponsibility(explicitSapWbsByLabel);
+    if (fromExplicitLabel) return fromExplicitLabel;
+    if (explicitSapWbsByLabel) return explicitSapWbsByLabel;
+
     const areaPath = this.toMewpComparableText(fields?.['System.AreaPath']);
     const fromAreaPath = this.resolveMewpResponsibility(areaPath);
     if (fromAreaPath) return fromAreaPath;
@@ -873,6 +1019,8 @@ ORDER BY [System.Id]`;
       if (name) return String(name).trim();
       const uniqueName = (value as any).uniqueName;
       if (uniqueName) return String(uniqueName).trim();
+      const objectValue = (value as any).value;
+      if (objectValue !== undefined && objectValue !== null) return String(objectValue).trim();
     }
     return String(value).trim();
   }

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

@@ -1075,7 +1075,7 @@ describe('ResultDataProvider', () => {
   });
 
   describe('getMewpL2CoverageFlatResults', () => {
-    it('should map SR ids from step action/expected and aggregate passed/failed/not-run by requirement', async () => {
+    it('should map SR ids from steps and output requirement-test-case coverage rows', 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([
@@ -1105,7 +1105,14 @@ describe('ResultDataProvider', () => {
         {
           workItemId: 5002,
           requirementId: 'SR1002',
-          title: 'Uncovered requirement',
+          title: 'Referenced from non-linked step text',
+          responsibility: 'IL',
+          linkedTestCaseIds: [],
+        },
+        {
+          workItemId: 5003,
+          requirementId: 'SR1003',
+          title: 'Not covered by any test case',
           responsibility: 'IL',
           linkedTestCaseIds: [],
         },
@@ -1113,6 +1120,7 @@ describe('ResultDataProvider', () => {
       jest.spyOn(resultDataProvider as any, 'fetchAllResultDataTestReporter').mockResolvedValueOnce([
         {
           testCaseId: 101,
+          testCase: { id: 101, name: 'TC 101' },
           iteration: {
             actionResults: [
               {
@@ -1127,6 +1135,7 @@ describe('ResultDataProvider', () => {
         },
         {
           testCaseId: 102,
+          testCase: { id: 102, name: 'TC 102' },
           iteration: undefined,
         },
       ]);
@@ -1151,25 +1160,50 @@ describe('ResultDataProvider', () => {
       expect(result).toEqual(
         expect.objectContaining({
           sheetName: expect.stringContaining('MEWP L2 Coverage'),
-          columnOrder: expect.arrayContaining(['Requirement ID', 'Number of steps not run']),
+          columnOrder: expect.arrayContaining(['Customer ID', 'Test case id', 'Number of not run tests']),
         })
       );
 
-      const covered = result.rows.find((row: any) => row['Requirement ID'] === 'SR1001');
-      const uncovered = result.rows.find((row: any) => row['Requirement ID'] === 'SR1002');
+      const covered = result.rows.find(
+        (row: any) => row['Customer ID'] === 'SR1001' && row['Test case id'] === 101
+      );
+      const inferredByStepText = result.rows.find(
+        (row: any) => row['Customer ID'] === 'SR1002' && row['Test case id'] === 102
+      );
+      const uncovered = result.rows.find(
+        (row: any) =>
+          row['Customer ID'] === 'SR1003' &&
+          (row['Test case id'] === '' || row['Test case id'] === undefined || row['Test case id'] === null)
+      );
 
       expect(covered).toEqual(
         expect.objectContaining({
+          'Title (Customer name)': 'Covered requirement',
+          'Responsibility - SAPWBS (ESUK/IL)': 'ESUK',
+          'Test case title': 'TC 101',
           'Number of passed steps': 1,
           'Number of failed steps': 1,
-          'Number of steps not run': 1,
+          'Number of not run tests': 1,
+        })
+      );
+      expect(inferredByStepText).toEqual(
+        expect.objectContaining({
+          'Title (Customer name)': 'Referenced from non-linked step text',
+          'Responsibility - SAPWBS (ESUK/IL)': 'IL',
+          'Test case title': 'TC 102',
+          'Number of passed steps': 0,
+          'Number of failed steps': 0,
+          'Number of not run tests': 1,
         })
       );
       expect(uncovered).toEqual(
         expect.objectContaining({
+          'Title (Customer name)': 'Not covered by any test case',
+          'Responsibility - SAPWBS (ESUK/IL)': 'IL',
+          'Test case title': '',
           'Number of passed steps': 0,
           'Number of failed steps': 0,
-          'Number of steps not run': 1,
+          'Number of not run tests': 0,
         })
       );
     });
@@ -1235,13 +1269,15 @@ describe('ResultDataProvider', () => {
         [1]
       );
 
-      const row = result.rows.find((item: any) => item['Requirement ID'] === 'SR2001');
+      const row = result.rows.find(
+        (item: any) => item['Customer ID'] === 'SR2001' && item['Test case id'] === 101
+      );
       expect(parseSpy).not.toHaveBeenCalled();
       expect(row).toEqual(
         expect.objectContaining({
           'Number of passed steps': 0,
           'Number of failed steps': 0,
-          'Number of steps not run': 0,
+          'Number of not run tests': 0,
         })
       );
     });
@@ -1256,7 +1292,16 @@ describe('ResultDataProvider', () => {
         4321
       );
 
-      expect(requirementId).toBe('4321');
+      expect(requirementId).toBe('SR4321');
+    });
+
+    it('should derive responsibility from Custom.SAPWBS when present', () => {
+      const responsibility = (resultDataProvider as any).deriveMewpResponsibility({
+        'Custom.SAPWBS': 'IL',
+        'System.AreaPath': 'MEWP\\ESUK',
+      });
+
+      expect(responsibility).toBe('IL');
     });
   });