@elisra-devops/docgen-data-provider 1.84.0 → 1.86.0

package/package.json

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

package/src/modules/ResultDataProvider.ts

@@ -478,6 +478,10 @@ export default class ResultDataProvider {
         testData
       );
       const requirementSapWbsByBaseKey = this.buildRequirementSapWbsByBaseKey(allRequirements);
+      const testCaseResponsibilityById = await this.buildMewpTestCaseResponsibilityMap(
+        testData,
+        projectName
+      );
       const externalBugsByTestCase = await this.loadExternalBugsByTestCase(options?.externalBugsFile);
       const externalL3L4ByBaseKey = await this.loadExternalL3L4ByBaseKey(
         options?.externalL3L4File,
@@ -690,7 +694,8 @@ export default class ResultDataProvider {
         linkedRequirementsByTestCase,
         externalL3L4ByBaseKey,
         externalBugsByTestCase,
-        externalJoinKeysByL2
+        externalJoinKeysByL2,
+        testCaseResponsibilityById
       );
       const coverageRowStats = rows.reduce(
         (acc, row) => {
@@ -843,18 +848,6 @@ export default class ResultDataProvider {
           [...mentionedL2Only].map((code) => this.toRequirementKey(code)).filter((code) => !!code)
         );
 
-        const expectedFamilyCodes = new Set<string>();
-        for (const baseKey of mentionedBaseKeys) {
-          const familyCodes = requirementFamilies.get(baseKey);
-          if (familyCodes?.size) {
-            familyCodes.forEach((code) => expectedFamilyCodes.add(code));
-          } else {
-            for (const code of mentionedL2Only) {
-              if (this.toRequirementKey(code) === baseKey) expectedFamilyCodes.add(code);
-            }
-          }
-        }
-
         const linkedFullCodesRaw = linkedRequirementsByTestCase.get(testCaseId)?.fullCodes || new Set<string>();
         const linkedFullCodes =
           scopedRequirementKeys?.size && linkedFullCodesRaw.size > 0
@@ -868,14 +861,48 @@ export default class ResultDataProvider {
           [...linkedFullCodes].map((code) => this.toRequirementKey(code)).filter((code) => !!code)
         );
 
-        const missingMentioned = [...mentionedL2Only].filter((code) => {
+        const mentionedCodesByBase = new Map<string, Set<string>>();
+        for (const code of mentionedL2Only) {
           const baseKey = this.toRequirementKey(code);
-          if (!baseKey) return false;
-          const hasSpecificSuffix = /-\d+$/.test(code);
-          if (hasSpecificSuffix) return !linkedFullCodes.has(code);
-          return !linkedBaseKeys.has(baseKey);
-        });
-        const missingFamily = [...expectedFamilyCodes].filter((code) => !linkedFullCodes.has(code));
+          if (!baseKey) continue;
+          if (!mentionedCodesByBase.has(baseKey)) mentionedCodesByBase.set(baseKey, new Set<string>());
+          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.
+        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);
+          if (familyCodes?.size) {
+            const missingInFamily = [...familyCodes].filter((code) => !linkedFullCodes.has(code));
+            if (missingInFamily.length === 0) continue;
+            const linkedInFamilyCount = familyCodes.size - missingInFamily.length;
+            if (linkedInFamilyCount === 0) {
+              missingBaseWhenFamilyUncovered.add(baseKey);
+            } else {
+              for (const code of missingInFamily) {
+                missingFamilyMembers.add(code);
+              }
+            }
+            continue;
+          }
+
+          // Fallback path when family data is unavailable for this base key.
+          for (const code of mentionedCodes) {
+            const hasSpecificSuffix = /-\d+$/.test(code);
+            if (hasSpecificSuffix) {
+              if (!linkedFullCodes.has(code)) missingSpecificMentionedNoFamily.add(code);
+            } else if (!linkedBaseKeys.has(baseKey)) {
+              missingBaseWhenFamilyUncovered.add(baseKey);
+            }
+          }
+        }
+
         // Direction B is family-based: if any member of a family is mentioned in Expected Result,
         // linked members of that same family are not considered "linked but not mentioned".
         const extraLinked = [...linkedFullCodes].filter((code) => {
@@ -894,13 +921,22 @@ export default class ResultDataProvider {
           mentionedButNotLinkedByStep.get(normalizedStepRef)!.add(normalizedRequirementId);
         };
 
-        const sortedMissingMentioned = [...new Set(missingMentioned)].sort((a, b) => a.localeCompare(b));
-        const sortedMissingFamily = [...new Set(missingFamily)].sort((a, b) => a.localeCompare(b));
-        for (const code of sortedMissingMentioned) {
+        const sortedMissingSpecificMentionedNoFamily = [...missingSpecificMentionedNoFamily].sort((a, b) =>
+          a.localeCompare(b)
+        );
+        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);
         }
-        for (const code of sortedMissingFamily) {
+        for (const baseKey of sortedMissingBaseWhenFamilyUncovered) {
+          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);
@@ -936,7 +972,11 @@ export default class ResultDataProvider {
           `MEWP internal validation parse diagnostics: ` +
             `testCaseId=${testCaseId} parsedSteps=${executableSteps.length} ` +
             `stepsWithMentions=${mentionEntries.length} customerIdsFound=${mentionedL2Only.size} ` +
-            `linkedRequirements=${linkedFullCodes.size} mentionedButNotLinked=${sortedMissingMentioned.length + sortedMissingFamily.length} ` +
+            `linkedRequirements=${linkedFullCodes.size} mentionedButNotLinked=${
+              sortedMissingSpecificMentionedNoFamily.length +
+              sortedMissingBaseWhenFamilyUncovered.length +
+              sortedMissingFamilyMembers.length
+            } ` +
             `linkedButNotMentioned=${sortedExtraLinked.length} status=${validationStatus} ` +
             `customerIdSample='${[...mentionedL2Only].slice(0, 5).join(', ')}'`
         );
@@ -1158,7 +1198,8 @@ export default class ResultDataProvider {
     linkedRequirementsByTestCase: MewpLinkedRequirementsByTestCase,
     l3l4ByBaseKey: Map<string, MewpL3L4Pair[]>,
     externalBugsByTestCase: Map<number, MewpBugLink[]>,
-    externalJoinKeysByL2?: Map<string, Set<string>>
+    externalJoinKeysByL2?: Map<string, Set<string>>,
+    testCaseResponsibilityById?: Map<number, string>
   ): MewpCoverageRow[] {
     const rows: MewpCoverageRow[] = [];
     const linkedByRequirement = this.invertBaseRequirementLinks(linkedRequirementsByTestCase);
@@ -1202,7 +1243,8 @@ export default class ResultDataProvider {
               ...bug,
               responsibility: this.resolveCoverageBugResponsibility(
                 String(bug?.responsibility || ''),
-                requirement
+                requirement,
+                String(testCaseResponsibilityById?.get(testCaseId) || '')
               ),
             });
           }
@@ -1246,18 +1288,127 @@ export default class ResultDataProvider {
 
   private resolveCoverageBugResponsibility(
     rawResponsibility: string,
-    requirement: Pick<MewpL2RequirementFamily, 'responsibility'>
+    requirement: Pick<MewpL2RequirementFamily, 'responsibility'>,
+    testCaseResponsibility: string = ''
   ): string {
-    const direct = String(rawResponsibility || '').trim();
+    const normalizeDisplay = (value: string): string => {
+      const direct = String(value || '').trim();
+      if (!direct) return '';
+      const resolved = this.resolveMewpResponsibility(this.toMewpComparableText(direct));
+      if (resolved === 'ESUK') return 'ESUK';
+      if (resolved === 'IL') return 'Elisra';
+      return direct;
+    };
+
+    const direct = normalizeDisplay(rawResponsibility);
     if (direct && direct.toLowerCase() !== 'unknown') return direct;
 
-    const requirementResponsibility = String(requirement?.responsibility || '')
-      .trim()
-      .toUpperCase();
-    if (requirementResponsibility === 'ESUK') return 'ESUK';
-    if (requirementResponsibility === 'IL' || requirementResponsibility === 'ELISRA') return 'Elisra';
+    const fromTestCase = normalizeDisplay(testCaseResponsibility);
+    if (fromTestCase && fromTestCase.toLowerCase() !== 'unknown') return fromTestCase;
+
+    const fromRequirement = normalizeDisplay(String(requirement?.responsibility || ''));
+    if (fromRequirement && fromRequirement.toLowerCase() !== 'unknown') return fromRequirement;
 
-    return direct || 'Unknown';
+    return direct || fromTestCase || fromRequirement || 'Unknown';
+  }
+
+  private async buildMewpTestCaseResponsibilityMap(
+    testData: any[],
+    projectName: string
+  ): Promise<Map<number, string>> {
+    const out = new Map<number, string>();
+    const unresolved = new Set<number>();
+
+    const extractFromWorkItemFields = (workItemFields: any): Record<string, any> => {
+      const fields: Record<string, any> = {};
+      if (!Array.isArray(workItemFields)) return fields;
+      for (const field of workItemFields) {
+        const keyCandidates = [field?.key, field?.name, field?.referenceName]
+          .map((item) => String(item || '').trim())
+          .filter((item) => !!item);
+        for (const key of keyCandidates) {
+          fields[key] = field?.value;
+        }
+      }
+      return fields;
+    };
+
+    for (const suite of testData || []) {
+      const testCasesItems = Array.isArray(suite?.testCasesItems) ? suite.testCasesItems : [];
+      for (const testCase of testCasesItems) {
+        const testCaseId = Number(testCase?.workItem?.id || testCase?.testCaseId || testCase?.id || 0);
+        if (!Number.isFinite(testCaseId) || testCaseId <= 0 || out.has(testCaseId)) continue;
+
+        const workItemFieldsMap = testCase?.workItem?.fields || {};
+        const workItemFieldsList = extractFromWorkItemFields(testCase?.workItem?.workItemFields);
+        const directFieldAliases = Object.fromEntries(
+          Object.entries({
+            'System.AreaPath':
+              testCase?.workItem?.areaPath ||
+              testCase?.workItem?.AreaPath ||
+              testCase?.areaPath ||
+              testCase?.AreaPath ||
+              testCase?.testCase?.areaPath ||
+              testCase?.testCase?.AreaPath,
+            'Area Path':
+              testCase?.workItem?.['Area Path'] ||
+              testCase?.['Area Path'] ||
+              testCase?.testCase?.['Area Path'],
+            AreaPath:
+              testCase?.workItem?.AreaPath ||
+              testCase?.AreaPath ||
+              testCase?.testCase?.AreaPath,
+          }).filter(([, value]) => value !== undefined && value !== null && String(value).trim() !== '')
+        );
+        const fromWorkItem = this.deriveMewpTestCaseResponsibility({
+          ...directFieldAliases,
+          ...workItemFieldsList,
+          ...workItemFieldsMap,
+        });
+
+        if (fromWorkItem) {
+          out.set(testCaseId, fromWorkItem);
+        } else {
+          unresolved.add(testCaseId);
+        }
+      }
+
+      const testPointsItems = Array.isArray(suite?.testPointsItems) ? suite.testPointsItems : [];
+      for (const testPoint of testPointsItems) {
+        const testCaseId = Number(testPoint?.testCaseId || testPoint?.testCase?.id || 0);
+        if (!Number.isFinite(testCaseId) || testCaseId <= 0 || out.has(testCaseId)) continue;
+        const fromPoint = this.deriveMewpTestCaseResponsibility({
+          'System.AreaPath': testPoint?.areaPath || testPoint?.AreaPath,
+          'Area Path': testPoint?.['Area Path'],
+          AreaPath: testPoint?.AreaPath,
+        });
+        if (fromPoint) {
+          out.set(testCaseId, fromPoint);
+          unresolved.delete(testCaseId);
+        } else {
+          unresolved.add(testCaseId);
+        }
+      }
+    }
+
+    if (unresolved.size > 0) {
+      try {
+        const workItems = await this.fetchWorkItemsByIds(projectName, [...unresolved], false);
+        for (const workItem of workItems || []) {
+          const testCaseId = Number(workItem?.id || 0);
+          if (!Number.isFinite(testCaseId) || testCaseId <= 0 || out.has(testCaseId)) continue;
+          const resolved = this.deriveMewpTestCaseResponsibility(workItem?.fields || {});
+          if (!resolved) continue;
+          out.set(testCaseId, resolved);
+        }
+      } catch (error: any) {
+        logger.warn(
+          `MEWP coverage: failed to enrich test-case responsibility fallback: ${error?.message || error}`
+        );
+      }
+    }
+
+    return out;
   }
 
   private resolveMewpL2RunStatus(input: {
@@ -2457,11 +2608,42 @@ export default class ResultDataProvider {
     if (fromExplicitLabel) return fromExplicitLabel;
     if (explicitSapWbsByLabel) return explicitSapWbsByLabel;
 
-    const areaPath = this.toMewpComparableText(fields?.['System.AreaPath']);
-    const fromAreaPath = this.resolveMewpResponsibility(areaPath);
-    if (fromAreaPath) return fromAreaPath;
+    const areaPathCandidates = [
+      fields?.['System.AreaPath'],
+      fields?.['Area Path'],
+      fields?.['AreaPath'],
+    ];
+    for (const candidate of areaPathCandidates) {
+      const normalized = this.toMewpComparableText(candidate);
+      const resolved = this.resolveMewpResponsibility(normalized);
+      if (resolved) return resolved;
+    }
+
+    const keyHints = ['sapwbs', 'responsibility', 'owner', 'areapath', 'area path'];
+    for (const [key, value] of Object.entries(fields || {})) {
+      const normalizedKey = String(key || '').toLowerCase();
+      if (!keyHints.some((hint) => normalizedKey.includes(hint))) continue;
+      const resolved = this.resolveMewpResponsibility(this.toMewpComparableText(value));
+      if (resolved) return resolved;
+    }
+
+    return '';
+  }
+
+  // Test-case responsibility must come from test-case path context (not SAPWBS).
+  private deriveMewpTestCaseResponsibility(fields: Record<string, any>): string {
+    const areaPathCandidates = [
+      fields?.['System.AreaPath'],
+      fields?.['Area Path'],
+      fields?.['AreaPath'],
+    ];
+    for (const candidate of areaPathCandidates) {
+      const normalized = this.toMewpComparableText(candidate);
+      const resolved = this.resolveMewpResponsibility(normalized);
+      if (resolved) return resolved;
+    }
 
-    const keyHints = ['sapwbs', 'responsibility', 'owner'];
+    const keyHints = ['areapath', 'area path', 'responsibility', 'owner'];
     for (const [key, value] of Object.entries(fields || {})) {
       const normalizedKey = String(key || '').toLowerCase();
       if (!keyHints.some((hint) => normalizedKey.includes(hint))) continue;
@@ -2905,7 +3087,6 @@ export default class ResultDataProvider {
           logger.warn(`Invalid run result ${runId} or result ${resultId}`);
           return null;
         }
-        logger.warn(`Current Test point for Test case ${point.testCaseId} is in Active state`);
         const url = `${this.orgUrl}${projectName}/_apis/wit/workItems/${point.testCaseId}?$expand=all`;
         const testCaseData = await TFSServices.getItemContent(url, this.token);
         const newResultData: PlainTestResult = {