@elisra-devops/docgen-data-provider 1.98.0 → 1.100.0

package/package.json

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

package/src/modules/ResultDataProvider.ts

@@ -4358,21 +4358,59 @@ export default class ResultDataProvider {
         }
       }
       for (const point of testItem.testPointsItems) {
-        const testCase = testCaseById.get(Number(point.testCaseId));
-        if (!testCase) continue;
+        const pointTestCaseId = Number(point?.testCaseId || 0);
+        const testCase =
+          testCaseById.get(pointTestCaseId) || {
+            workItem: { id: pointTestCaseId, workItemFields: [] },
+          };
+        if (!Number.isFinite(pointTestCaseId) || pointTestCaseId <= 0) continue;
+
+        if (!testCaseById.has(pointTestCaseId) && isTestReporter) {
+          logger.debug(
+            `[RunlessResolver] Missing suite testCase payload for point testCaseId=${String(
+              pointTestCaseId
+            )}; using point fallback for alignment`
+          );
+        }
 
-        if (testCase.workItem.workItemFields.length === 0) {
+        const testCaseWorkItemFields = Array.isArray(testCase?.workItem?.workItemFields)
+          ? testCase.workItem.workItemFields
+          : [];
+        if (testCaseWorkItemFields.length === 0) {
           logger.warn(`Could not fetch the steps from WI ${JSON.stringify(testCase.workItem.id)}`);
           if (!isTestReporter) {
             continue;
           }
         }
-        const iterationKey =
-          !point.lastRunId || !point.lastResultId
-            ? `${testCase.workItem.id}`
-            : `${point.lastRunId}-${point.lastResultId}-${testCase.workItem.id}`;
+        const iterationKey = this.buildIterationLookupKey({
+          testCaseId: testCase.workItem.id,
+          lastRunId: point?.lastRunId,
+          lastResultId: point?.lastResultId,
+          testPointId: point?.testPointId,
+          testCaseRevision:
+            this.resolveSuiteTestCaseRevision(testCase) ||
+            this.resolveSuiteTestCaseRevision(point?.suiteTestCase),
+        });
+        const fallbackRevision = Number(
+          this.resolveSuiteTestCaseRevision(testCase) ||
+            this.resolveSuiteTestCaseRevision(point?.suiteTestCase) ||
+            0
+        );
+        const fallbackRevisionKey =
+          Number.isFinite(fallbackRevision) && fallbackRevision > 0
+            ? this.buildIterationLookupKey({
+                testCaseId: testCase.workItem.id,
+                testCaseRevision: fallbackRevision,
+              })
+            : '';
+        const fallbackCaseOnlyKey = `${testCase.workItem.id}`;
         const fetchedTestCase =
-          iterationsMap[iterationKey] || (includeNotRunTestCases ? testCase : undefined);
+          iterationsMap[iterationKey] ||
+          (fallbackRevisionKey && fallbackRevisionKey !== iterationKey
+            ? iterationsMap[fallbackRevisionKey]
+            : undefined) ||
+          (iterationKey !== fallbackCaseOnlyKey ? iterationsMap[fallbackCaseOnlyKey] : undefined) ||
+          (includeNotRunTestCases ? testCase : undefined);
         // First check if fetchedTestCase exists
         if (!fetchedTestCase) continue;
 
@@ -4515,26 +4553,80 @@ export default class ResultDataProvider {
         String(iterationItem?.lastResultId).trim() !== '';
 
       if (hasRunIdentifiers) {
-        const key = `${iterationItem.lastRunId}-${iterationItem.lastResultId}-${iterationItem.testCaseId}`;
+        const key = this.buildIterationLookupKey({
+          testCaseId: iterationItem?.testCaseId,
+          lastRunId: iterationItem?.lastRunId,
+          lastResultId: iterationItem?.lastResultId,
+          testPointId: iterationItem?.testPointId,
+          testCaseRevision: iterationItem?.testCaseRevision,
+        });
         map[key] = iterationItem;
       } else if (includeNotRunTestCases) {
-        const key = `${iterationItem.testCaseId}`;
+        const key = this.buildIterationLookupKey({
+          testCaseId: iterationItem?.testCaseId,
+          lastRunId: iterationItem?.lastRunId,
+          lastResultId: iterationItem?.lastResultId,
+          testPointId: iterationItem?.testPointId,
+          testCaseRevision: iterationItem?.testCaseRevision,
+        });
         map[key] = iterationItem;
         if (isTestReporter && iterationItem?.iteration) {
           logger.debug(
             `[RunlessResolver] createIterationsMap: mapped runless testCaseId=${String(
               iterationItem?.testCaseId
-            )} to case-only key`
+            )} to key=${key}`
           );
         }
       } else if (iterationItem?.iteration && !isTestReporter) {
-        const key = `${iterationItem.lastRunId}-${iterationItem.lastResultId}-${iterationItem.testCaseId}`;
+        const key = this.buildIterationLookupKey({
+          testCaseId: iterationItem?.testCaseId,
+          lastRunId: iterationItem?.lastRunId,
+          lastResultId: iterationItem?.lastResultId,
+          testPointId: iterationItem?.testPointId,
+          testCaseRevision: iterationItem?.testCaseRevision,
+        });
         map[key] = iterationItem;
       }
       return map;
     }, {} as Record<string, any>);
   }
 
+  /**
+   * Builds a stable lookup key for joining points to fetched iteration payloads.
+   * Run-backed items are keyed by run/result/testCase, while runless items prefer
+   * testPointId to avoid collisions across suites that share the same testCaseId.
+   */
+  private buildIterationLookupKey(input: {
+    testCaseId: any;
+    lastRunId?: any;
+    lastResultId?: any;
+    testPointId?: any;
+    testCaseRevision?: any;
+  }): string {
+    const testCaseId = Number(input?.testCaseId || 0);
+    const hasRunIdentifiers =
+      input?.lastRunId !== undefined &&
+      input?.lastRunId !== null &&
+      String(input?.lastRunId).trim() !== '' &&
+      input?.lastResultId !== undefined &&
+      input?.lastResultId !== null &&
+      String(input?.lastResultId).trim() !== '';
+    if (hasRunIdentifiers) {
+      return `${input?.lastRunId}-${input?.lastResultId}-${testCaseId}`;
+    }
+
+    const testPointId = Number(input?.testPointId || 0);
+    if (Number.isFinite(testPointId) && testPointId > 0) {
+      return `point-${testPointId}-${testCaseId}`;
+    }
+
+    const testCaseRevision = Number(input?.testCaseRevision || 0);
+    if (Number.isFinite(testCaseRevision) && testCaseRevision > 0) {
+      return `rev-${testCaseId}-${testCaseRevision}`;
+    }
+    return `${testCaseId}`;
+  }
+
   /**
    * Fetches test data for all suites, including test points and test cases.
    */
@@ -5463,6 +5555,7 @@ export default class ResultDataProvider {
           const resultDataResponse: any = {
             testCaseName: `${resultData?.testCase?.name ?? ''} - ${resultData?.testCase?.id ?? ''}`,
             testCaseId: resultData?.testCase?.id,
+            testPointId: point?.testPointId,
             testSuiteName: `${resultData?.testSuite?.name ?? ''}`,
             testSuiteId,
             lastRunId,

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

@@ -5129,7 +5129,7 @@ describe('ResultDataProvider', () => {
       expect(result['1']).toBeDefined();
     });
 
-    it('should map runless test reporter item with iteration by testCaseId key', () => {
+    it('should map runless test reporter item with iteration by testCaseId key when point id is missing', () => {
       const iterations = [
         { testCaseId: 217897, lastRunId: undefined, lastResultId: undefined, iteration: { actionResults: [] } },
       ];
@@ -5139,6 +5139,40 @@ describe('ResultDataProvider', () => {
       expect(result['217897']).toBeDefined();
       expect(result['undefined-undefined-217897']).toBeUndefined();
     });
+
+    it('should map runless test reporter item with iteration by point-aware key when point id exists', () => {
+      const iterations = [
+        {
+          testCaseId: 217916,
+          testPointId: 1001,
+          lastRunId: undefined,
+          lastResultId: undefined,
+          iteration: { actionResults: [] },
+        },
+      ];
+
+      const result = (resultDataProvider as any).createIterationsMap(iterations, true, true);
+
+      expect(result['point-1001-217916']).toBeDefined();
+      expect(result['217916']).toBeUndefined();
+    });
+
+    it('should map runless test reporter item with iteration by revision key when point id is missing', () => {
+      const iterations = [
+        {
+          testCaseId: 217916,
+          testCaseRevision: 18,
+          lastRunId: undefined,
+          lastResultId: undefined,
+          iteration: { actionResults: [] },
+        },
+      ];
+
+      const result = (resultDataProvider as any).createIterationsMap(iterations, true, true);
+
+      expect(result['rev-217916-18']).toBeDefined();
+      expect(result['217916']).toBeUndefined();
+    });
   });
 
   describe('alignStepsWithIterationsBase', () => {
@@ -6080,6 +6114,227 @@ describe('ResultDataProvider', () => {
       expect(res).toHaveLength(1);
       expect(res[0].stepNo).toBeUndefined();
     });
+
+    it('should keep runless step rows even when suite testCasesItems entry is missing', () => {
+      const testData = [
+        {
+          testGroupName: 'G',
+          testPointsItems: [{ testCaseId: 217916, testPointId: 1001, testCaseName: 'TC 217916', testCaseUrl: 'u' }],
+          testCasesItems: [],
+        },
+      ];
+      const iterations = [
+        {
+          testCaseId: 217916,
+          testPointId: 1001,
+          lastRunId: undefined,
+          lastResultId: undefined,
+          iteration: {
+            actionResults: [
+              {
+                stepIdentifier: '16',
+                stepPosition: '1',
+                action: 'A',
+                expected: 'E',
+                outcome: 'Unspecified',
+                isSharedStepTitle: false,
+                errorMessage: '',
+              },
+            ],
+          },
+          testCaseResult: 'Not Run',
+          comment: '',
+          runBy: { displayName: 'u' },
+          failureType: '',
+          executionDate: '',
+          configurationName: '',
+          relatedRequirements: [],
+          relatedBugs: [],
+          relatedCRs: [],
+          customFields: {},
+        },
+      ];
+
+      const res = (resultDataProvider as any).alignStepsWithIterationsTestReporter(
+        testData,
+        iterations,
+        ['includeSteps@stepsRunProperties', 'stepRunStatus@stepsRunProperties'],
+        true
+      );
+
+      expect(res).toHaveLength(1);
+      expect(res[0]).toEqual(expect.objectContaining({ stepNo: '1', stepStatus: 'Not Run' }));
+    });
+
+    it('should match runless iterations by testPointId when the same testCase appears in multiple suites', () => {
+      const testData = [
+        {
+          testGroupName: 'Suite A',
+          testPointsItems: [{ testCaseId: 217916, testPointId: 2001, testCaseName: 'TC', testCaseUrl: 'u1' }],
+          testCasesItems: [],
+        },
+        {
+          testGroupName: 'Suite B',
+          testPointsItems: [{ testCaseId: 217916, testPointId: 2002, testCaseName: 'TC', testCaseUrl: 'u2' }],
+          testCasesItems: [],
+        },
+      ];
+
+      const iterations = [
+        {
+          testCaseId: 217916,
+          testPointId: 2001,
+          lastRunId: undefined,
+          lastResultId: undefined,
+          iteration: {
+            actionResults: [
+              {
+                stepIdentifier: '16',
+                stepPosition: '1',
+                action: 'A',
+                expected: 'E',
+                outcome: 'Unspecified',
+                isSharedStepTitle: false,
+                errorMessage: '',
+              },
+            ],
+          },
+          testCaseResult: 'Not Run',
+          comment: '',
+          runBy: { displayName: 'u' },
+          failureType: '',
+          executionDate: '',
+          configurationName: '',
+          relatedRequirements: [],
+          relatedBugs: [],
+          relatedCRs: [],
+          customFields: {},
+        },
+        {
+          testCaseId: 217916,
+          testPointId: 2002,
+          lastRunId: undefined,
+          lastResultId: undefined,
+          iteration: { actionResults: [] },
+          testCaseResult: 'Not Run',
+          comment: '',
+          runBy: { displayName: 'u' },
+          failureType: '',
+          executionDate: '',
+          configurationName: '',
+          relatedRequirements: [],
+          relatedBugs: [],
+          relatedCRs: [],
+          customFields: {},
+        },
+      ];
+
+      const res = (resultDataProvider as any).alignStepsWithIterationsTestReporter(
+        testData,
+        iterations,
+        ['includeSteps@stepsRunProperties', 'stepRunStatus@stepsRunProperties'],
+        true
+      );
+
+      expect(res).toHaveLength(2);
+      const suiteA = res.find((row: any) => row?.suiteName === 'Suite A');
+      const suiteB = res.find((row: any) => row?.suiteName === 'Suite B');
+      expect(suiteA).toEqual(expect.objectContaining({ stepNo: '1', stepStatus: 'Not Run' }));
+      expect(suiteB).toBeDefined();
+      expect(Object.prototype.hasOwnProperty.call(suiteB, 'stepNo')).toBe(false);
+    });
+
+    it('should match runless iterations by revision when point id is missing and same testCase appears in multiple suites', () => {
+      const testData = [
+        {
+          testGroupName: 'Suite A',
+          testPointsItems: [{ testCaseId: 217916, testCaseName: 'TC', testCaseUrl: 'u1' }],
+          testCasesItems: [
+            {
+              workItem: {
+                id: 217916,
+                workItemFields: [{ key: 'System.Rev', value: 18 }],
+              },
+            },
+          ],
+        },
+        {
+          testGroupName: 'Suite B',
+          testPointsItems: [{ testCaseId: 217916, testCaseName: 'TC', testCaseUrl: 'u2' }],
+          testCasesItems: [
+            {
+              workItem: {
+                id: 217916,
+                workItemFields: [{ key: 'System.Rev', value: 23 }],
+              },
+            },
+          ],
+        },
+      ];
+
+      const iterations = [
+        {
+          testCaseId: 217916,
+          testCaseRevision: 18,
+          lastRunId: undefined,
+          lastResultId: undefined,
+          iteration: {
+            actionResults: [
+              {
+                stepIdentifier: '16',
+                stepPosition: '1',
+                action: 'A',
+                expected: 'E',
+                outcome: 'Unspecified',
+                isSharedStepTitle: false,
+                errorMessage: '',
+              },
+            ],
+          },
+          testCaseResult: 'Not Run',
+          comment: '',
+          runBy: { displayName: 'u' },
+          failureType: '',
+          executionDate: '',
+          configurationName: '',
+          relatedRequirements: [],
+          relatedBugs: [],
+          relatedCRs: [],
+          customFields: {},
+        },
+        {
+          testCaseId: 217916,
+          testCaseRevision: 23,
+          lastRunId: undefined,
+          lastResultId: undefined,
+          iteration: { actionResults: [] },
+          testCaseResult: 'Not Run',
+          comment: '',
+          runBy: { displayName: 'u' },
+          failureType: '',
+          executionDate: '',
+          configurationName: '',
+          relatedRequirements: [],
+          relatedBugs: [],
+          relatedCRs: [],
+          customFields: {},
+        },
+      ];
+
+      const res = (resultDataProvider as any).alignStepsWithIterationsTestReporter(
+        testData,
+        iterations,
+        ['includeSteps@stepsRunProperties', 'stepRunStatus@stepsRunProperties'],
+        true
+      );
+
+      expect(res).toHaveLength(2);
+      const suiteA = res.find((row: any) => row?.suiteName === 'Suite A');
+      const suiteB = res.find((row: any) => row?.suiteName === 'Suite B');
+      expect(suiteA).toEqual(expect.objectContaining({ stepNo: '1', stepStatus: 'Not Run' }));
+      expect(suiteB).toBeDefined();
+      expect(Object.prototype.hasOwnProperty.call(suiteB, 'stepNo')).toBe(false);
+    });
   });
 
   describe('fetchOpenPcrData', () => {