@elisra-devops/docgen-data-provider 1.95.0 → 1.97.0

package/package.json

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

package/src/modules/ResultDataProvider.ts

@@ -3362,6 +3362,11 @@ export default class ResultDataProvider {
     const parsedAsOf = new Date(String(asOfTimestamp || '').trim());
     if (!Number.isFinite(id) || id <= 0 || Number.isNaN(parsedAsOf.getTime())) return null;
 
+    logger.debug(
+      `[RunlessResolver] Fetching work item ${id} by asOf (raw="${String(
+        asOfTimestamp || ''
+      )}", normalized="${parsedAsOf.toISOString()}", expandAll=${String(expandAll)})`
+    );
     const query: string[] = [`asOf=${encodeURIComponent(parsedAsOf.toISOString())}`];
     if (expandAll) {
       query.push(`$expand=all`);
@@ -3395,6 +3400,29 @@ export default class ResultDataProvider {
     }
   }
 
+  /**
+   * Returns true when the snapshot includes a non-empty test steps XML payload.
+   */
+  private hasStepsInWorkItemSnapshot(workItemData: any): boolean {
+    const stepsXml = this.extractStepsXmlFromFieldsMap(workItemData?.fields || {});
+    return String(stepsXml || '').trim() !== '';
+  }
+
+  private logRunlessSnapshotDecision(testCaseId: number, source: string, snapshot: any | null): void {
+    if (!snapshot) {
+      logger.debug(`[RunlessResolver] TC ${testCaseId}: source=${source}, snapshot=none`);
+      return;
+    }
+
+    const stepsXml = this.extractStepsXmlFromFieldsMap(snapshot?.fields || {});
+    const stepsLength = String(stepsXml || '').trim().length;
+    logger.debug(
+      `[RunlessResolver] TC ${testCaseId}: source=${source}, rev=${String(
+        snapshot?.rev ?? ''
+      )}, hasSteps=${String(stepsLength > 0)}, stepsLength=${String(stepsLength)}`
+    );
+  }
+
   /**
    * Resolves runless test case data using ordered fallbacks:
    * 1) point-based `asOf` snapshot, 2) explicit revision, 3) suite payload snapshot, 4) latest WI.
@@ -3407,6 +3435,8 @@ export default class ResultDataProvider {
     fallbackSnapshot: any,
     expandAll: boolean
   ): Promise<any | null> {
+    let bestSnapshotWithoutSteps: any | null = null;
+
     if (pointAsOfTimestamp) {
       const asOfSnapshot = await this.fetchWorkItemByAsOf(
         projectName,
@@ -3414,7 +3444,13 @@ export default class ResultDataProvider {
         pointAsOfTimestamp,
         expandAll
       );
-      if (asOfSnapshot) return asOfSnapshot;
+      this.logRunlessSnapshotDecision(testCaseId, 'asOf', asOfSnapshot);
+      if (asOfSnapshot) {
+        if (this.hasStepsInWorkItemSnapshot(asOfSnapshot)) return asOfSnapshot;
+        bestSnapshotWithoutSteps = asOfSnapshot;
+      }
+    } else {
+      logger.debug(`[RunlessResolver] TC ${testCaseId}: asOf timestamp is empty, skipping asOf fetch`);
     }
 
     const revisionSnapshot = await this.fetchWorkItemByRevision(
@@ -3423,11 +3459,26 @@ export default class ResultDataProvider {
       suiteTestCaseRevision,
       expandAll
     );
-    if (revisionSnapshot) return revisionSnapshot;
+    this.logRunlessSnapshotDecision(testCaseId, `revision:${String(suiteTestCaseRevision)}`, revisionSnapshot);
+    if (revisionSnapshot) {
+      if (this.hasStepsInWorkItemSnapshot(revisionSnapshot)) return revisionSnapshot;
+      bestSnapshotWithoutSteps = bestSnapshotWithoutSteps || revisionSnapshot;
+    }
 
-    if (fallbackSnapshot) return fallbackSnapshot;
+    this.logRunlessSnapshotDecision(testCaseId, 'suiteSnapshot', fallbackSnapshot);
+    if (fallbackSnapshot) {
+      if (this.hasStepsInWorkItemSnapshot(fallbackSnapshot)) return fallbackSnapshot;
+      bestSnapshotWithoutSteps = bestSnapshotWithoutSteps || fallbackSnapshot;
+    }
 
-    return this.fetchWorkItemLatest(projectName, testCaseId, expandAll);
+    const latestSnapshot = await this.fetchWorkItemLatest(projectName, testCaseId, expandAll);
+    this.logRunlessSnapshotDecision(testCaseId, 'latest', latestSnapshot);
+    if (latestSnapshot) {
+      if (this.hasStepsInWorkItemSnapshot(latestSnapshot)) return latestSnapshot;
+      bestSnapshotWithoutSteps = bestSnapshotWithoutSteps || latestSnapshot;
+    }
+
+    return bestSnapshotWithoutSteps;
   }
 
   /**
@@ -3473,6 +3524,13 @@ export default class ResultDataProvider {
         const pointAsOfTimestamp = useRunlessAsOf
           ? String(point?.pointAsOfTimestamp || '').trim()
           : '';
+        logger.debug(
+          `[RunlessResolver] Start TC ${String(testCaseId)}: useRunlessAsOf=${String(
+            useRunlessAsOf
+          )}, pointAsOfTimestamp="${pointAsOfTimestamp}", suiteRevision=${String(
+            suiteTestCaseRevision
+          )}, pointOutcome="${String(point?.outcome || '')}"`
+        );
         const fallbackSnapshot = this.buildWorkItemSnapshotFromSuiteTestCase(
           suiteTestCaseItem,
           testCaseId,
@@ -4441,15 +4499,30 @@ export default class ResultDataProvider {
     includeNotRunTestCases: boolean
   ): Record<string, any> {
     return iterations.reduce((map, iterationItem) => {
-      if (
-        (isTestReporter && iterationItem.lastRunId && iterationItem.lastResultId) ||
-        iterationItem.iteration
-      ) {
+      const hasRunIdentifiers =
+        iterationItem?.lastRunId !== undefined &&
+        iterationItem?.lastRunId !== null &&
+        String(iterationItem?.lastRunId).trim() !== '' &&
+        iterationItem?.lastResultId !== undefined &&
+        iterationItem?.lastResultId !== null &&
+        String(iterationItem?.lastResultId).trim() !== '';
+
+      if (hasRunIdentifiers) {
         const key = `${iterationItem.lastRunId}-${iterationItem.lastResultId}-${iterationItem.testCaseId}`;
         map[key] = iterationItem;
       } else if (includeNotRunTestCases) {
         const key = `${iterationItem.testCaseId}`;
         map[key] = iterationItem;
+        if (isTestReporter && iterationItem?.iteration) {
+          logger.debug(
+            `[RunlessResolver] createIterationsMap: mapped runless testCaseId=${String(
+              iterationItem?.testCaseId
+            )} to case-only key`
+          );
+        }
+      } else if (iterationItem?.iteration && !isTestReporter) {
+        const key = `${iterationItem.lastRunId}-${iterationItem.lastResultId}-${iterationItem.testCaseId}`;
+        map[key] = iterationItem;
       }
       return map;
     }, {} as Record<string, any>);

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

@@ -4012,6 +4012,70 @@ describe('ResultDataProvider', () => {
       expect(res).toEqual(expect.objectContaining({ testCaseRevision: 6 }));
     });
 
+    it('should fallback from asOf snapshot without steps to revision snapshot with steps', async () => {
+      (TFSServices.getItemContent as jest.Mock).mockReset();
+      const point = {
+        testCaseId: '777',
+        testCaseName: 'TC 777',
+        outcome: 'Not Run',
+        pointAsOfTimestamp: '2025-03-01T00:00:00Z',
+        suiteTestCase: {
+          workItem: {
+            id: 777,
+            workItemFields: [{ key: 'System.Rev', value: '21' }],
+          },
+        },
+        testSuite: { id: '1', name: 'Suite' },
+      };
+
+      (TFSServices.getItemContent as jest.Mock)
+        .mockResolvedValueOnce({
+          id: 777,
+          rev: 18,
+          fields: {
+            'System.State': 'Design',
+            'System.CreatedDate': '2024-01-01T00:00:00',
+            'Microsoft.VSTS.TCM.Priority': 1,
+            'System.Title': 'TC 777',
+          },
+          relations: [],
+        })
+        .mockResolvedValueOnce({
+          id: 777,
+          rev: 21,
+          fields: {
+            'System.State': 'Design',
+            'System.CreatedDate': '2024-01-01T00:00:00',
+            'Microsoft.VSTS.TCM.Priority': 1,
+            'System.Title': 'TC 777',
+            'Microsoft.VSTS.TCM.Steps': '<steps></steps>',
+          },
+          relations: [],
+        });
+
+      const res = await (resultDataProvider as any).fetchResultDataBasedOnWiBase(
+        mockProjectName,
+        '0',
+        '0',
+        true,
+        [],
+        false,
+        point,
+        false,
+        true
+      );
+
+      const calledUrls = (TFSServices.getItemContent as jest.Mock).mock.calls.map((args: any[]) => String(args[0]));
+      expect(calledUrls.some((url: string) => url.includes('/_apis/wit/workItems/777?asOf='))).toBe(true);
+      expect(calledUrls.some((url: string) => url.includes('/_apis/wit/workItems/777/revisions/21'))).toBe(true);
+      expect(res).toEqual(
+        expect.objectContaining({
+          testCaseRevision: 21,
+          stepsResultXml: '<steps></steps>',
+        })
+      );
+    });
+
     it('should fallback to suite revision when asOf fetch fails', async () => {
       (TFSServices.getItemContent as jest.Mock).mockReset();
       const point = {
@@ -5064,6 +5128,17 @@ describe('ResultDataProvider', () => {
       // Assert
       expect(result['1']).toBeDefined();
     });
+
+    it('should map runless test reporter item with iteration by testCaseId key', () => {
+      const iterations = [
+        { testCaseId: 217897, lastRunId: undefined, lastResultId: undefined, iteration: { actionResults: [] } },
+      ];
+
+      const result = (resultDataProvider as any).createIterationsMap(iterations, true, true);
+
+      expect(result['217897']).toBeDefined();
+      expect(result['undefined-undefined-217897']).toBeUndefined();
+    });
   });
 
   describe('alignStepsWithIterationsBase', () => {