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

package/src/models/mewp-reporting.ts

@@ -42,6 +42,7 @@ export interface MewpL2RequirementWorkItem {
 }
 
 export interface MewpL2RequirementFamily {
+  workItemId?: number;
   requirementId: string;
   baseKey: string;
   title: string;

package/src/modules/ResultDataProvider.ts

@@ -598,6 +598,69 @@ export default class ResultDataProvider {
         );
       }
 
+      const requirementBaseKeys = new Set<string>(
+        requirements.map((item) => String(item?.baseKey || '').trim()).filter((item) => !!item)
+      );
+      const externalL3L4BaseKeys = new Set<string>([...externalL3L4ByBaseKey.keys()]);
+      const externalL3L4OverlapKeys = [...externalL3L4BaseKeys].filter((key) => requirementBaseKeys.has(key));
+      const failedRequirementBaseKeys = new Set<string>();
+      const failedTestCaseIds = new Set<number>();
+      for (const [requirementBaseKey, byTestCase] of requirementIndex.entries()) {
+        for (const [testCaseId, counts] of byTestCase.entries()) {
+          if (Number(counts?.failed || 0) > 0) {
+            failedRequirementBaseKeys.add(requirementBaseKey);
+            failedTestCaseIds.add(testCaseId);
+          }
+        }
+      }
+      const externalBugTestCaseIds = new Set<number>([...externalBugsByTestCase.keys()]);
+      const externalBugFailedTestCaseOverlap = [...externalBugTestCaseIds].filter((id) =>
+        failedTestCaseIds.has(id)
+      );
+      const externalBugBaseKeys = new Set<string>();
+      for (const bugs of externalBugsByTestCase.values()) {
+        for (const bug of bugs || []) {
+          const key = String(bug?.requirementBaseKey || '').trim();
+          if (key) externalBugBaseKeys.add(key);
+        }
+      }
+      const externalBugRequirementOverlap = [...externalBugBaseKeys].filter((key) =>
+        requirementBaseKeys.has(key)
+      );
+      const externalBugFailedRequirementOverlap = [...externalBugBaseKeys].filter((key) =>
+        failedRequirementBaseKeys.has(key)
+      );
+      logger.info(
+        `MEWP coverage join diagnostics: requirementBaseKeys=${requirementBaseKeys.size} ` +
+          `failedRequirementBaseKeys=${failedRequirementBaseKeys.size} failedTestCases=${failedTestCaseIds.size}; ` +
+          `externalL3L4BaseKeys=${externalL3L4BaseKeys.size} externalL3L4Overlap=${externalL3L4OverlapKeys.length}; ` +
+          `externalBugTestCases=${externalBugTestCaseIds.size} externalBugFailedTestCaseOverlap=${externalBugFailedTestCaseOverlap.length}; ` +
+          `externalBugBaseKeys=${externalBugBaseKeys.size} externalBugRequirementOverlap=${externalBugRequirementOverlap.length} ` +
+          `externalBugFailedRequirementOverlap=${externalBugFailedRequirementOverlap.length}`
+      );
+      if (externalL3L4BaseKeys.size > 0 && externalL3L4OverlapKeys.length === 0) {
+        const sampleReq = [...requirementBaseKeys].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(', ')}`
+        );
+      }
+      if (externalBugBaseKeys.size > 0 && externalBugRequirementOverlap.length === 0) {
+        const sampleReq = [...requirementBaseKeys].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(', ')}`
+        );
+      }
+      if (externalBugTestCaseIds.size > 0 && externalBugFailedTestCaseOverlap.length === 0) {
+        logger.warn(
+          `MEWP coverage join diagnostics: no overlap between external bug test cases and failed test cases. ` +
+            `Bug rows remain empty because bugs are shown only for failed L2s.`
+        );
+      }
+
       const rows = this.buildMewpCoverageRows(
         requirements,
         requirementIndex,
@@ -936,12 +999,16 @@ export default class ResultDataProvider {
   }
 
   private createMewpCoverageRow(
-    requirement: Pick<MewpL2RequirementFamily, 'requirementId' | 'title' | 'subSystem' | 'responsibility'>,
+    requirement: Pick<
+      MewpL2RequirementFamily,
+      'workItemId' | 'requirementId' | 'title' | 'subSystem' | 'responsibility'
+    >,
     runStatus: MewpRunStatus,
     bug: MewpCoverageBugCell,
     linkedL3L4: MewpCoverageL3L4Cell
   ): MewpCoverageRow {
-    const l2ReqId = this.formatMewpCustomerId(requirement.requirementId);
+    const l2ReqIdNumeric = Number(requirement?.workItemId || 0);
+    const l2ReqId = l2ReqIdNumeric > 0 ? String(l2ReqIdNumeric) : '';
     const l2ReqTitle = this.toMewpComparableText(requirement.title);
     const l2SubSystem = this.toMewpComparableText(requirement.subSystem);
 
@@ -987,15 +1054,6 @@ export default class ResultDataProvider {
     return rows;
   }
 
-  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: MewpL2RequirementFamily[],
     requirementIndex: MewpRequirementIndex,
@@ -1727,7 +1785,7 @@ export default class ResultDataProvider {
     const workItems = await this.fetchWorkItemsByIds(projectName, requirementIds, true);
     const requirements = workItems.map((wi: any) => {
       const fields = wi?.fields || {};
-      const requirementId = this.extractMewpRequirementIdentifier(fields, Number(wi?.id || 0));
+      const requirementId = this.extractMewpRequirementIdentifier(fields);
       const areaPath = this.toMewpComparableText(fields?.['System.AreaPath']);
       return {
         workItemId: Number(wi?.id || 0),
@@ -1815,6 +1873,7 @@ export default class ResultDataProvider {
 
     return [...families.entries()]
       .map(([baseKey, family]) => ({
+        workItemId: Number(family?.representative?.workItemId || 0),
         requirementId: String(family?.representative?.requirementId || baseKey),
         baseKey,
         title: String(family?.representative?.title || ''),
@@ -2090,47 +2149,33 @@ export default class ResultDataProvider {
     return [...out].sort((a, b) => a - b);
   }
 
-  private extractMewpRequirementIdentifier(fields: Record<string, any>, fallbackWorkItemId: number): string {
+  private extractMewpRequirementIdentifier(fields: Record<string, any>): string {
     const entries = Object.entries(fields || {});
-
-    // First pass: only trusted identifier-like fields.
-    const strictHints = [
+    const normalizeFieldKey = (value: string): string =>
+      String(value || '')
+        .toLowerCase()
+        .replace(/[^a-z0-9]/g, '');
+
+    // Strict MEWP mode: only explicit MEWP customer-id fields are accepted.
+    // API display name: "Customer ID"
+    // API reference name: "Custom.CustomerID"
+    const customerIdFieldKeys = new Set<string>([
       'customerid',
-      'customer id',
-      'customerrequirementid',
-      'requirementid',
-      'externalid',
-      'srid',
-      'sapwbsid',
-    ];
-    for (const [key, value] of entries) {
-      const normalizedKey = String(key || '').toLowerCase();
-      if (!strictHints.some((hint) => normalizedKey.includes(hint))) continue;
-
-      const valueAsString = this.toMewpComparableText(value);
-      if (!valueAsString) continue;
-      const normalized = this.normalizeMewpRequirementCodeWithSuffix(valueAsString);
-      if (normalized) return normalized;
-    }
+      'customcustomerid',
+    ]);
 
-    // Second pass: weaker hints, but still key-based only.
-    const looseHints = ['customer', 'requirement', 'external', 'sapwbs', 'sr'];
     for (const [key, value] of entries) {
-      const normalizedKey = String(key || '').toLowerCase();
-      if (!looseHints.some((hint) => normalizedKey.includes(hint))) continue;
+      const normalizedKey = normalizeFieldKey(key);
+      if (!customerIdFieldKeys.has(normalizedKey)) continue;
 
       const valueAsString = this.toMewpComparableText(value);
       if (!valueAsString) continue;
-      const normalized = this.normalizeMewpRequirementCodeWithSuffix(valueAsString);
-      if (normalized) return normalized;
-    }
 
-    // Optional fallback from title only (avoid scanning all fields and accidental SR matches).
-    const title = this.toMewpComparableText(fields?.['System.Title']);
-    const titleCode = this.normalizeMewpRequirementCodeWithSuffix(title);
-    if (titleCode) return titleCode;
+      const normalizedRequirementId = this.normalizeMewpRequirementCodeWithSuffix(valueAsString);
+      if (normalizedRequirementId) return normalizedRequirementId;
+    }
 
-    return fallbackWorkItemId ? `SR${fallbackWorkItemId}` : '';
+    return '';
   }
 
   private deriveMewpResponsibility(fields: Record<string, any>): string {

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

@@ -1178,9 +1178,9 @@ describe('ResultDataProvider', () => {
         })
       );
 
-      const covered = result.rows.find((row: any) => row['L2 REQ ID'] === 'SR1001');
-      const inferredByStepText = result.rows.find((row: any) => row['L2 REQ ID'] === 'SR1002');
-      const uncovered = result.rows.find((row: any) => row['L2 REQ ID'] === 'SR1003');
+      const covered = result.rows.find((row: any) => row['L2 REQ ID'] === '5001');
+      const inferredByStepText = result.rows.find((row: any) => row['L2 REQ ID'] === '5002');
+      const uncovered = result.rows.find((row: any) => row['L2 REQ ID'] === '5003');
 
       expect(covered).toEqual(
         expect.objectContaining({
@@ -1297,7 +1297,7 @@ describe('ResultDataProvider', () => {
         [1]
       );
 
-      const row = result.rows.find((item: any) => item['L2 REQ ID'] === 'SR2001');
+      const row = result.rows.find((item: any) => item['L2 REQ ID'] === '7001');
       expect(parseSpy).not.toHaveBeenCalled();
       expect(row).toEqual(
         expect.objectContaining({
@@ -1312,11 +1312,10 @@ describe('ResultDataProvider', () => {
           'System.Description': 'random text with SR9999 that is unrelated',
           'Custom.CustomerId': 'customer id unknown',
           'System.Title': 'Requirement without explicit SR code',
-        },
-        4321
+        }
       );
 
-      expect(requirementId).toBe('SR4321');
+      expect(requirementId).toBe('');
     });
 
     it('should derive responsibility from Custom.SAPWBS when present', () => {