@elisra-devops/docgen-data-provider 1.94.0 → 1.96.0

package/package.json

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

package/src/modules/ResultDataProvider.ts

@@ -410,7 +410,8 @@ export default class ResultDataProvider {
         projectName,
         selectedFields,
         false,
-        includeAllHistory
+        includeAllHistory,
+        true
       );
 
       const rows = this.alignStepsWithIterationsFlatReport(
@@ -3086,40 +3087,108 @@ export default class ResultDataProvider {
    * Maps raw test point data to a simplified object.
    */
   private mapTestPoint(testPoint: any, projectName: string): any {
-    return {
-      testPointId: testPoint.id,
-      testCaseId: testPoint.testCaseReference.id,
-      testCaseName: testPoint.testCaseReference.name,
-      testCaseUrl: `${this.orgUrl}${projectName}/_workitems/edit/${testPoint.testCaseReference.id}`,
-      configurationName: testPoint.configuration?.name,
-      outcome: testPoint.results?.outcome || 'Not Run',
-      testSuite: testPoint.testSuite,
-      lastRunId: testPoint.results?.lastTestRunId,
-      lastResultId: testPoint.results?.lastResultId,
-      lastResultDetails: testPoint.results?.lastResultDetails,
-    };
+    const pointAsOfTimestamp = this.resolvePointAsOfTimestamp(testPoint);
+    return this.buildMappedTestPoint(
+      {
+        testPointId: testPoint.id,
+        testCaseId: testPoint.testCaseReference.id,
+        testCaseName: testPoint.testCaseReference.name,
+        configurationName: testPoint.configuration?.name,
+        outcome: testPoint.results?.outcome,
+        testSuite: testPoint.testSuite,
+        lastRunId: testPoint.results?.lastTestRunId,
+        lastResultId: testPoint.results?.lastResultId,
+        lastResultDetails: testPoint.results?.lastResultDetails,
+      },
+      projectName,
+      pointAsOfTimestamp
+    );
   }
 
   /**
    * Maps raw test point data to a simplified object.
    */
   private mapTestPointForCrossPlans(testPoint: any, projectName: string): any {
-    return {
-      testPointId: testPoint.id,
-      testCaseId: testPoint.testCase.id,
-      testCaseName: testPoint.testCase.name,
-      testCaseUrl: `${this.orgUrl}${projectName}/_workitems/edit/${testPoint.testCase.id}`,
-      testSuite: testPoint.testSuite,
-      configurationName: testPoint.configuration?.name,
-      outcome: testPoint.outcome || 'Not Run',
-      lastRunId: testPoint.lastTestRun?.id,
-      lastResultId: testPoint.lastResult?.id,
-      lastResultDetails: testPoint.lastResultDetails || {
-        duration: 0,
-        dateCompleted: '0000-00-00T00:00:00.000Z',
-        runBy: { displayName: 'No tester', id: '00000000-0000-0000-0000-000000000000' },
+    const pointAsOfTimestamp = this.resolvePointAsOfTimestamp(testPoint);
+    return this.buildMappedTestPoint(
+      {
+        testPointId: testPoint.id,
+        testCaseId: testPoint.testCase.id,
+        testCaseName: testPoint.testCase.name,
+        configurationName: testPoint.configuration?.name,
+        outcome: testPoint.outcome,
+        testSuite: testPoint.testSuite,
+        lastRunId: testPoint.lastTestRun?.id,
+        lastResultId: testPoint.lastResult?.id,
+        lastResultDetails: testPoint.lastResultDetails || {
+          duration: 0,
+          dateCompleted: '0000-00-00T00:00:00.000Z',
+          runBy: { displayName: 'No tester', id: '00000000-0000-0000-0000-000000000000' },
+        },
       },
+      projectName,
+      pointAsOfTimestamp
+    );
+  }
+
+  /**
+   * Resolves a point timestamp that can be used as WIT `asOf` anchor.
+   * Returns an ISO string when a valid date exists, otherwise an empty string.
+   */
+  private resolvePointAsOfTimestamp(testPoint: any): string {
+    const candidates = [
+      testPoint?.lastUpdatedDate,
+      testPoint?.lastUpdatedOn,
+      testPoint?.updatedDate,
+      testPoint?.updatedOn,
+    ];
+
+    for (const candidate of candidates) {
+      const raw = String(candidate || '').trim();
+      if (!raw) continue;
+      const parsed = new Date(raw);
+      if (!Number.isNaN(parsed.getTime())) {
+        return parsed.toISOString();
+      }
+    }
+
+    return '';
+  }
+
+  /**
+   * Builds a normalized test point shape used by downstream result fetch flows.
+   */
+  private buildMappedTestPoint(
+    pointData: {
+      testPointId: any;
+      testCaseId: any;
+      testCaseName: any;
+      configurationName?: any;
+      outcome?: any;
+      testSuite?: any;
+      lastRunId?: any;
+      lastResultId?: any;
+      lastResultDetails?: any;
+    },
+    projectName: string,
+    pointAsOfTimestamp: string
+  ): any {
+    const mappedPoint: any = {
+      testPointId: pointData.testPointId,
+      testCaseId: pointData.testCaseId,
+      testCaseName: pointData.testCaseName,
+      testCaseUrl: `${this.orgUrl}${projectName}/_workitems/edit/${pointData.testCaseId}`,
+      configurationName: pointData.configurationName,
+      outcome: pointData.outcome || 'Not Run',
+      testSuite: pointData.testSuite,
+      lastRunId: pointData.lastRunId,
+      lastResultId: pointData.lastResultId,
+      lastResultDetails: pointData.lastResultDetails,
     };
+    if (pointAsOfTimestamp) {
+      mappedPoint.pointAsOfTimestamp = pointAsOfTimestamp;
+    }
+    return mappedPoint;
   }
 
   // Helper method to get all test points for a test case
@@ -3186,6 +3255,9 @@ export default class ResultDataProvider {
     return fields;
   }
 
+  /**
+   * Reads a field value by reference name with case-insensitive key matching.
+   */
   private getFieldValueByName(fields: Record<string, any>, fieldName: string): any {
     if (!fields || typeof fields !== 'object') return undefined;
     if (Object.prototype.hasOwnProperty.call(fields, fieldName)) {
@@ -3277,12 +3349,30 @@ export default class ResultDataProvider {
 
     const expandParam = expandAll ? '?$expand=all' : '';
     const url = `${this.orgUrl}${projectName}/_apis/wit/workItems/${id}/revisions/${rev}${expandParam}`;
-    try {
-      return await TFSServices.getItemContent(url, this.token);
-    } catch (error: any) {
-      logger.warn(`Failed to fetch work item ${id} by revision ${rev}: ${error?.message || error}`);
-      return null;
+    return this.fetchWorkItemByUrl(url, `work item ${id} by revision ${rev}`);
+  }
+
+  private async fetchWorkItemByAsOf(
+    projectName: string,
+    workItemId: number,
+    asOfTimestamp: string,
+    expandAll: boolean = false
+  ): Promise<any | null> {
+    const id = Number(workItemId || 0);
+    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`);
     }
+    const url = `${this.orgUrl}${projectName}/_apis/wit/workItems/${id}?${query.join('&')}`;
+    return this.fetchWorkItemByUrl(url, `work item ${id} by asOf ${parsedAsOf.toISOString()}`);
   }
 
   private async fetchWorkItemLatest(
@@ -3295,14 +3385,102 @@ export default class ResultDataProvider {
 
     const expandParam = expandAll ? '?$expand=all' : '';
     const url = `${this.orgUrl}${projectName}/_apis/wit/workItems/${id}${expandParam}`;
+    return this.fetchWorkItemByUrl(url, `latest work item ${id}`);
+  }
+
+  /**
+   * Executes a work-item GET by URL and applies consistent warning/error handling.
+   */
+  private async fetchWorkItemByUrl(url: string, failureContext: string): Promise<any | null> {
     try {
       return await TFSServices.getItemContent(url, this.token);
     } catch (error: any) {
-      logger.warn(`Failed to fetch latest work item ${id}: ${error?.message || error}`);
+      logger.warn(`Failed to fetch ${failureContext}: ${error?.message || error}`);
       return null;
     }
   }
 
+  /**
+   * 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.
+   */
+  private async resolveRunlessTestCaseData(
+    projectName: string,
+    testCaseId: number,
+    suiteTestCaseRevision: number,
+    pointAsOfTimestamp: string,
+    fallbackSnapshot: any,
+    expandAll: boolean
+  ): Promise<any | null> {
+    let bestSnapshotWithoutSteps: any | null = null;
+
+    if (pointAsOfTimestamp) {
+      const asOfSnapshot = await this.fetchWorkItemByAsOf(
+        projectName,
+        testCaseId,
+        pointAsOfTimestamp,
+        expandAll
+      );
+      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(
+      projectName,
+      testCaseId,
+      suiteTestCaseRevision,
+      expandAll
+    );
+    this.logRunlessSnapshotDecision(testCaseId, `revision:${String(suiteTestCaseRevision)}`, revisionSnapshot);
+    if (revisionSnapshot) {
+      if (this.hasStepsInWorkItemSnapshot(revisionSnapshot)) return revisionSnapshot;
+      bestSnapshotWithoutSteps = bestSnapshotWithoutSteps || revisionSnapshot;
+    }
+
+    this.logRunlessSnapshotDecision(testCaseId, 'suiteSnapshot', fallbackSnapshot);
+    if (fallbackSnapshot) {
+      if (this.hasStepsInWorkItemSnapshot(fallbackSnapshot)) return fallbackSnapshot;
+      bestSnapshotWithoutSteps = bestSnapshotWithoutSteps || fallbackSnapshot;
+    }
+
+    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;
+  }
+
   /**
    * Fetches result data based on the Work Item Test Reporter.
    *
@@ -3325,7 +3503,8 @@ export default class ResultDataProvider {
     selectedFields?: string[],
     isQueryMode?: boolean,
     point?: any,
-    includeAllHistory: boolean = false
+    includeAllHistory: boolean = false,
+    useRunlessAsOf: boolean = false
   ): Promise<any> {
     try {
       let filteredFields: any = {};
@@ -3342,23 +3521,29 @@ export default class ResultDataProvider {
           point?.testCaseId || suiteTestCaseItem?.workItem?.id || suiteTestCaseItem?.testCaseId || 0
         );
         const suiteTestCaseRevision = this.resolveSuiteTestCaseRevision(suiteTestCaseItem);
+        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,
           String(point?.testCaseName || '')
         );
-        let testCaseData = await this.fetchWorkItemByRevision(
+        const testCaseData = await this.resolveRunlessTestCaseData(
           projectName,
           testCaseId,
           suiteTestCaseRevision,
+          pointAsOfTimestamp,
+          fallbackSnapshot,
           isTestReporter
         );
-        if (!testCaseData) {
-          testCaseData = fallbackSnapshot;
-        }
-        if (!testCaseData) {
-          testCaseData = await this.fetchWorkItemLatest(projectName, testCaseId, isTestReporter);
-        }
         if (!testCaseData) {
           logger.warn(`Could not resolve test case ${point.testCaseId} for runless point fallback.`);
           return null;
@@ -4992,7 +5177,8 @@ export default class ResultDataProvider {
     selectedFields?: string[],
     isQueryMode?: boolean,
     point?: any,
-    includeAllHistory: boolean = false
+    includeAllHistory: boolean = false,
+    useRunlessAsOf: boolean = false
   ): Promise<any> {
     return this.fetchResultDataBasedOnWiBase(
       projectName,
@@ -5002,7 +5188,8 @@ export default class ResultDataProvider {
       selectedFields,
       isQueryMode,
       point,
-      includeAllHistory
+      includeAllHistory,
+      useRunlessAsOf
     );
   }
 
@@ -5023,22 +5210,24 @@ export default class ResultDataProvider {
     projectName: string,
     selectedFields?: string[],
     isQueryMode?: boolean,
-    includeAllHistory: boolean = false
+    includeAllHistory: boolean = false,
+    useRunlessAsOf: boolean = false
   ): Promise<any[]> {
     return this.fetchAllResultDataBase(
       testData,
       projectName,
       true,
-      (projectName, testSuiteId, point, selectedFields, isQueryMode, includeAllHistory) =>
+      (projectName, testSuiteId, point, selectedFields, isQueryMode, includeAllHistory, useRunlessAsOf) =>
         this.fetchResultDataForTestReporter(
           projectName,
           testSuiteId,
           point,
           selectedFields,
           isQueryMode,
-          includeAllHistory
+          includeAllHistory,
+          useRunlessAsOf
         ),
-      [selectedFields, isQueryMode, includeAllHistory]
+      [selectedFields, isQueryMode, includeAllHistory, useRunlessAsOf]
     );
   }
 
@@ -5196,13 +5385,14 @@ export default class ResultDataProvider {
     point: any,
     selectedFields?: string[],
     isQueryMode?: boolean,
-    includeAllHistory: boolean = false
+    includeAllHistory: boolean = false,
+    useRunlessAsOf: boolean = false
   ) {
     return this.fetchResultDataBase(
       projectName,
       testSuiteId,
       point,
-      (project, runId, resultId, fields, isQueryMode, point, includeAllHistory) =>
+      (project, runId, resultId, fields, isQueryMode, point, includeAllHistory, useRunlessAsOf) =>
         this.fetchResultDataBasedOnWiTestReporter(
           project,
           runId,
@@ -5210,7 +5400,8 @@ export default class ResultDataProvider {
           fields,
           isQueryMode,
           point,
-          includeAllHistory
+          includeAllHistory,
+          useRunlessAsOf
         ),
       (resultData, testSuiteId, point, selectedFields) => {
         const { lastRunId, lastResultId, configurationName, lastResultDetails } = point;
@@ -5330,7 +5521,7 @@ export default class ResultDataProvider {
           return null;
         }
       },
-      [selectedFields, isQueryMode, point, includeAllHistory]
+      [selectedFields, isQueryMode, point, includeAllHistory, useRunlessAsOf]
     );
   }
 

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

@@ -333,6 +333,21 @@ describe('ResultDataProvider', () => {
           testCaseUrl: 'https://dev.azure.com/organization/test-project/_workitems/edit/1',
         });
       });
+
+      it('should include pointAsOfTimestamp when lastUpdatedDate is available', () => {
+        const testPoint = {
+          testCaseReference: { id: 1, name: 'Test Case 1' },
+          lastUpdatedDate: '2025-01-01T12:34:56Z',
+        };
+
+        const result = (resultDataProvider as any).mapTestPoint(testPoint, mockProjectName);
+
+        expect(result).toEqual(
+          expect.objectContaining({
+            pointAsOfTimestamp: '2025-01-01T12:34:56.000Z',
+          })
+        );
+      });
     });
 
     describe('calculateGroupResultSummary', () => {
@@ -3890,7 +3905,9 @@ describe('ResultDataProvider', () => {
         true,
         [],
         false,
-        point
+        point,
+        false,
+        true
       );
 
       expect(TFSServices.getItemContent).toHaveBeenCalledWith(
@@ -3902,7 +3919,214 @@ describe('ResultDataProvider', () => {
       expect(res).toEqual(expect.objectContaining({ testCaseRevision: 9 }));
     });
 
+    it('should ignore point asOf timestamp when runless asOf mode is disabled', async () => {
+      const point = {
+        testCaseId: '123',
+        testCaseName: 'TC 123',
+        outcome: 'passed',
+        pointAsOfTimestamp: '2025-01-01T12:34:56Z',
+        suiteTestCase: {
+          workItem: {
+            id: 123,
+            rev: 9,
+            workItemFields: [{ key: 'Microsoft.VSTS.TCM.Steps', value: '<steps></steps>' }],
+          },
+        },
+        testSuite: { id: '1', name: 'Suite' },
+      };
+
+      (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce({
+        id: 123,
+        rev: 9,
+        fields: {
+          'System.State': 'Active',
+          'System.CreatedDate': '2024-01-01T00:00:00',
+          'Microsoft.VSTS.TCM.Priority': 1,
+          'System.Title': 'Title 123',
+          'Microsoft.VSTS.TCM.Steps': '<steps></steps>',
+        },
+        relations: null,
+      });
+
+      const res = await (resultDataProvider as any).fetchResultDataBasedOnWiBase(
+        mockProjectName,
+        '0',
+        '0',
+        true,
+        [],
+        false,
+        point
+      );
+
+      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/123?asOf='))).toBe(false);
+      expect(calledUrls.some((url: string) => url.includes('/_apis/wit/workItems/123/revisions/9'))).toBe(true);
+      expect(res).toEqual(expect.objectContaining({ testCaseRevision: 9 }));
+    });
+
+    it('should fetch no-run test case by asOf timestamp when pointAsOfTimestamp is available', async () => {
+      (TFSServices.getItemContent as jest.Mock).mockReset();
+      const point = {
+        testCaseId: '123',
+        testCaseName: 'TC 123',
+        outcome: 'passed',
+        pointAsOfTimestamp: '2025-01-01T12:34:56Z',
+        suiteTestCase: {
+          workItem: {
+            id: 123,
+            rev: 9,
+            workItemFields: [{ key: 'Microsoft.VSTS.TCM.Steps', value: '<steps></steps>' }],
+          },
+        },
+        testSuite: { id: '1', name: 'Suite' },
+      };
+
+      (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce({
+        id: 123,
+        rev: 6,
+        fields: {
+          'System.State': 'Active',
+          'System.CreatedDate': '2024-01-01T00:00:00',
+          'Microsoft.VSTS.TCM.Priority': 1,
+          'System.Title': 'Title 123',
+          'Microsoft.VSTS.TCM.Steps': '<steps></steps>',
+        },
+        relations: null,
+      });
+
+      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/123?asOf='))).toBe(true);
+      expect(calledUrls.some((url: string) => url.includes('/revisions/9'))).toBe(false);
+      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 = {
+        testCaseId: '456',
+        testCaseName: 'TC 456',
+        outcome: 'Not Run',
+        pointAsOfTimestamp: '2025-02-01T00:00:00Z',
+        suiteTestCase: {
+          workItem: {
+            id: 456,
+            workItemFields: [{ key: 'System.Rev', value: '11' }],
+          },
+        },
+        testSuite: { id: '1', name: 'Suite' },
+      };
+
+      (TFSServices.getItemContent as jest.Mock)
+        .mockRejectedValueOnce(new Error('asOf failed'))
+        .mockResolvedValueOnce({
+          id: 456,
+          rev: 11,
+          fields: {
+            'System.State': 'Active',
+            'System.CreatedDate': '2024-01-01T00:00:00',
+            'Microsoft.VSTS.TCM.Priority': 1,
+            'System.Title': 'Title 456',
+            '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/456?asOf='))).toBe(true);
+      expect(calledUrls.some((url: string) => url.includes('/_apis/wit/workItems/456/revisions/11'))).toBe(true);
+      expect(res).toEqual(expect.objectContaining({ testCaseRevision: 11 }));
+    });
+
     it('should resolve no-run revision from System.Rev in suite test-case fields', async () => {
+      (TFSServices.getItemContent as jest.Mock).mockReset();
       const point = {
         testCaseId: '321',
         testCaseName: 'TC 321',