@elisra-devops/docgen-data-provider 1.139.0 → 1.141.0

package/src/modules/ResultDataProvider.ts

@@ -259,10 +259,22 @@ export default class ResultDataProvider {
 
       return { combinedResults, openPcrToTestCaseTraceMap, testCaseToOpenPcrTraceMap };
     } catch (error: any) {
-      logger.error(`Error during getCombinedResultsSummary: ${error.message}`);
+      // One event, one record — this used to be two separate calls (message, then
+      // conditionally the response body), which interleave with other requests' output
+      // under concurrency and become two unrelated entries in the dashboard's error grouping.
+      let responseSummary: string | undefined;
       if (error.response) {
-        logger.error(`Response Data: ${JSON.stringify(error.response.data)}`);
+        // Truncated to match the bound already used for this in tfs.ts — an untruncated ADO
+        // response body isn't a credential, but it can still be large/sensitive work-item content
+        // and doesn't need to go into logs unbounded. JSON.stringify itself (not just the
+        // output) can throw on a circular value, so that has to be guarded too, not just capped.
+        try {
+          responseSummary = JSON.stringify(error.response.data).substring(0, 200);
+        } catch {
+          responseSummary = '[unserializable response data]';
+        }
       }
+      logger.error(`Error during getCombinedResultsSummary: ${error.message}`, { responseSummary });
       // Ensure the error is rethrown to propagate it correctly
       throw new Error(error.message || 'Unknown error occurred during getCombinedResultsSummary');
     }
@@ -3261,8 +3273,7 @@ export default class ResultDataProvider {
       );
       return detailedPoints;
     } catch (err: any) {
-      logger.error(`Error during fetching Cross Test Points: ${err.message}`);
-      logger.error(`Error stack: ${err.stack}`);
+      logger.error('Error during fetching Cross Test Points', err);
       return [];
     }
   }
@@ -3903,10 +3914,7 @@ export default class ResultDataProvider {
         relatedCRs,
       };
     } catch (error: any) {
-      logger.error(`Error while fetching run result: ${error.message}`);
-      if (isTestReporter) {
-        logger.error(`Error stack: ${error.stack}`);
-      }
+      logger.error('Error while fetching run result', error);
       return null;
     }
   }
@@ -4595,7 +4603,7 @@ export default class ResultDataProvider {
           ? testCase.workItem.workItemFields
           : [];
         if (testCaseWorkItemFields.length === 0) {
-          logger.warn(`Could not fetch the steps from WI ${JSON.stringify(testCase.workItem.id)}`);
+          logger.warn(`Could not fetch the steps from WI ${testCase.workItem.id}`);
           if (!isTestReporter) {
             continue;
           }
@@ -5058,8 +5066,7 @@ export default class ResultDataProvider {
         ? createResponseObject(resultData, testSuiteId, point, ...additionalArgs)
         : null;
     } catch (error: any) {
-      logger.error(`Error occurred for point ${point.testCaseId}: ${error.message}`);
-      logger.error(`Stack trace: ${error.stack}`);
+      logger.error(`Error occurred for point ${point.testCaseId}`, error);
       return null;
     }
   }
@@ -5153,8 +5160,7 @@ export default class ResultDataProvider {
           summarizedItemMap.set(wi.id, mappedItem);
         }
       } catch (error: any) {
-        logger.error(`Error occurred while fetching linked work items: ${error.message}`);
-        logger.error(`Error Stack: ${error.stack}`);
+        logger.error('Error occurred while fetching linked work items', error);
       }
     }
 
@@ -5826,8 +5832,7 @@ export default class ResultDataProvider {
           }
           return resultDataResponse;
         } catch (err: any) {
-          logger.error(`Error occurred while fetching result data: ${err.message}`);
-          logger.error(`Error stack: ${err.stack}`);
+          logger.error('Error occurred while fetching result data', err);
           return null;
         }
       },

package/src/modules/TicketsDataProvider.ts

@@ -98,9 +98,11 @@ export default class TicketsDataProvider {
   token: string = '';
   queriesList: Array<any> = new Array<any>();
   private limit = pLimit(10);
-  // Set once a workitemsbatch call reports one of HISTORICAL_OPTIONAL_WORK_ITEM_FIELDS
-  // as unknown for this project, so only the first chunk pays the retry cost.
-  private historicalFieldsOverride: string[] | null = null;
+  // Resolved once per project via resolveHistoricalTestPhaseField, so a
+  // compare's baseline and compareTo snapshots (and repeated queries against
+  // the same provider instance) only pay the discovery call once. Value is
+  // the real reference name, or null if the project defines no such field.
+  private historicalTestPhaseFieldByProject = new Map<string, Promise<string | null>>();
 
   constructor(orgUrl: string, token: string) {
     this.orgUrl = orgUrl;
@@ -781,11 +783,9 @@ export default class TicketsDataProvider {
         : null;
     } catch (err: any) {
       logger.error(
-        `Error occurred while constructing the customer query list ${err.message} with query ${JSON.stringify(
-          rootQuery,
-        )}`,
+        `Error occurred while constructing the customer query list with query ${JSON.stringify(rootQuery)}`,
+        err,
       );
-      logger.error(`Error stack ${err.message}`);
       return null;
     }
   }
@@ -2042,25 +2042,61 @@ export default class TicketsDataProvider {
     return /TF51535|Cannot find field/i.test(message);
   }
 
-  // ADO's TF51535 names the specific field it couldn't find, e.g.
-  // "TF51535: Cannot find field 'Elisra.TestPhase'." — different networks
-  // define this optional field under different reference names (Elisra.* vs
-  // Custom.*), so drop only the one ADO actually rejected rather than every
-  // optional field, or a network that defines Custom.TestPhase but not
-  // Elisra.TestPhase would lose Test Phase comparison entirely for no reason.
-  private extractHistoricalUnknownFieldName(error: any): string | null {
-    const message = this.historicalErrorMessage(error);
-    const quoted = message.match(/Cannot find field\s*'([^']+)'/i);
-    if (quoted?.[1]) return quoted[1];
-    return HISTORICAL_OPTIONAL_WORK_ITEM_FIELDS.find((field) => message.includes(field)) || null;
+  // Different networks define the "Test Phase" custom field under different
+  // reference names (Elisra.TestPhase vs Custom.TestPhase, or something else
+  // entirely on a third network) — hardcoding candidate names and guessing is
+  // inherently fragile. Resolve the project's real field list once (Fields -
+  // List: GET {org}/{project}/_apis/wit/fields, supported since old TFS API
+  // versions) and use whichever reference name actually matches, by
+  // reference name or by friendly name. Resolves to null if the project
+  // defines no such field at all.
+  //
+  // Caches the in-flight promise, not just the resolved value: a compare's
+  // baseline and compareTo snapshots run concurrently against the same
+  // provider instance, and both would otherwise read the cache before either
+  // had a value to store, issuing the discovery request twice.
+  private resolveHistoricalTestPhaseField(project: string, apiVersion: string | null): Promise<string | null> {
+    const cached = this.historicalTestPhaseFieldByProject.get(project);
+    if (cached) return cached;
+    const promise = this.discoverHistoricalTestPhaseField(project, apiVersion);
+    this.historicalTestPhaseFieldByProject.set(project, promise);
+    return promise;
+  }
+
+  private async discoverHistoricalTestPhaseField(
+    project: string,
+    apiVersion: string | null,
+  ): Promise<string | null> {
+    const fieldsUrl = this.appendApiVersion(`${this.orgUrl}${project}/_apis/wit/fields`, apiVersion);
+    try {
+      const response = await TFSServices.getItemContent(fieldsUrl, this.token);
+      const fields = Array.isArray(response?.value) ? response.value : [];
+      const match =
+        fields.find((field: any) =>
+          HISTORICAL_OPTIONAL_WORK_ITEM_FIELDS.some(
+            (candidate) => String(field?.referenceName || '').toLowerCase() === candidate.toLowerCase(),
+          ),
+        ) || fields.find((field: any) => /test\s*phase/i.test(String(field?.name || '')));
+      const resolved = match?.referenceName ? String(match.referenceName) : null;
+      if (!resolved) {
+        logger.warn(`[historical-workitems] no Test Phase field defined for project '${project}'`);
+      }
+      return resolved;
+    } catch (error: any) {
+      logger.warn(
+        `[historical-workitems] could not list fields for project '${project}' to resolve the ` +
+          `Test Phase field name, omitting it: ${this.historicalErrorMessage(error)}`,
+      );
+      return null;
+    }
   }
 
-  private fetchHistoricalFieldsBatchAttempt(
+  private fetchHistoricalFieldsBatch(
     workItemsBatchUrl: string,
     idChunk: number[],
     asOf: string,
+    project: string,
     fieldsForRequest: string[],
-    attemptsRemaining: number,
   ): Promise<any> {
     return this.limit(() =>
       TFSServices.getItemContent(workItemsBatchUrl, this.token, 'post', {
@@ -2070,57 +2106,31 @@ export default class TicketsDataProvider {
         errorPolicy: 'Omit',
       }),
     ).catch((error: any) => {
-      if (attemptsRemaining <= 0 || !this.isHistoricalUnknownFieldError(error)) {
+      // Defensive net: the resolved field name came from the project's own
+      // field list, so this shouldn't fire, but if it somehow still does,
+      // fall back to the required fields and poison the cache so later
+      // chunks/queries for this project stop requesting it too.
+      const hasOptionalField = HISTORICAL_OPTIONAL_WORK_ITEM_FIELDS.some((f) => fieldsForRequest.includes(f))
+        || fieldsForRequest.some((f) => !HISTORICAL_REQUIRED_WORK_ITEM_FIELDS.includes(f));
+      if (!hasOptionalField || !this.isHistoricalUnknownFieldError(error)) {
         throw error;
       }
-      const unknownField = this.extractHistoricalUnknownFieldName(error);
-      // Only strip fields this call actually recognizes as droppable
-      // (named explicitly, or one of the known optional fields as a
-      // last-resort fallback if the message doesn't parse) — never strip a
-      // required field, so an unrelated schema issue still surfaces as an
-      // error instead of silently losing data.
-      const reducedFields = unknownField
-        ? fieldsForRequest.filter((field) => field !== unknownField)
-        : fieldsForRequest.filter((field) => !HISTORICAL_OPTIONAL_WORK_ITEM_FIELDS.includes(field));
-      if (reducedFields.length === fieldsForRequest.length) {
-        throw error;
-      }
-      // Concurrent chunks can each discover a different bad field before any
-      // of them updates the shared override — intersect rather than
-      // overwrite, so one chunk's retry never re-requests a field another
-      // chunk already proved invalid for this project.
-      this.historicalFieldsOverride = this.historicalFieldsOverride
-        ? this.historicalFieldsOverride.filter((field) => reducedFields.includes(field))
-        : reducedFields;
       logger.warn(
-        `[historical-workitems] field${unknownField ? ` '${unknownField}'` : '(s)'} not defined ` +
-          `for this project; retrying workitemsbatch without it: ${this.historicalErrorMessage(error)}`,
+        `[historical-workitems] resolved Test Phase field was rejected by workitemsbatch for ` +
+          `project '${project}'; retrying without it: ${this.historicalErrorMessage(error)}`,
       );
-      return this.fetchHistoricalFieldsBatchAttempt(
-        workItemsBatchUrl,
-        idChunk,
-        asOf,
-        reducedFields,
-        attemptsRemaining - 1,
+      this.historicalTestPhaseFieldByProject.set(project, Promise.resolve(null));
+      return this.limit(() =>
+        TFSServices.getItemContent(workItemsBatchUrl, this.token, 'post', {
+          ids: idChunk,
+          asOf,
+          fields: HISTORICAL_REQUIRED_WORK_ITEM_FIELDS,
+          errorPolicy: 'Omit',
+        }),
       );
     });
   }
 
-  private fetchHistoricalFieldsBatch(
-    workItemsBatchUrl: string,
-    idChunk: number[],
-    asOf: string,
-  ): Promise<any> {
-    const fieldsForRequest = this.historicalFieldsOverride || HISTORICAL_WORK_ITEM_FIELDS;
-    return this.fetchHistoricalFieldsBatchAttempt(
-      workItemsBatchUrl,
-      idChunk,
-      asOf,
-      fieldsForRequest,
-      HISTORICAL_OPTIONAL_WORK_ITEM_FIELDS.length,
-    );
-  }
-
   private async fetchHistoricalWorkItemsBatch(
     project: string,
     ids: number[],
@@ -2131,6 +2141,12 @@ export default class TicketsDataProvider {
       `${this.orgUrl}${project}/_apis/wit/workitemsbatch`,
       apiVersion,
     );
+    // Resolved once per project, before any chunk starts, so every chunk
+    // shares the same field list — no per-request guessing or retry race.
+    const testPhaseField = await this.resolveHistoricalTestPhaseField(project, apiVersion);
+    const fieldsForRequest = testPhaseField
+      ? [...HISTORICAL_REQUIRED_WORK_ITEM_FIELDS, testPhaseField]
+      : HISTORICAL_REQUIRED_WORK_ITEM_FIELDS;
     const idChunks = this.chunkHistoricalWorkItemIds(ids);
     try {
       const chunkResults = await Promise.all(
@@ -2147,7 +2163,7 @@ export default class TicketsDataProvider {
           // two units against the shared concurrency cap, not one — otherwise
           // the real ceiling on simultaneous ADO calls would silently double.
           Promise.all([
-            this.fetchHistoricalFieldsBatch(workItemsBatchUrl, idChunk, asOf),
+            this.fetchHistoricalFieldsBatch(workItemsBatchUrl, idChunk, asOf, project, fieldsForRequest),
             this.limit(() =>
               TFSServices.getItemContent(workItemsBatchUrl, this.token, 'post', {
                 ids: idChunk,
@@ -2679,8 +2695,10 @@ export default class TicketsDataProvider {
         const subRes = await postBatch(currentIds);
         res.push(...subRes.value);
       } catch (error) {
-        logger.error(`error populating workitems array`);
-        logger.error(JSON.stringify(error));
+        // JSON.stringify(error) on an AxiosError calls its own .toJSON(), which serializes
+        // config.auth.password / config.headers.Authorization — the PAT, in plaintext. Pass
+        // the error as meta instead and let the logger's redact format scrub it.
+        logger.error(`error populating workitems array`, error);
         return [];
       }
     }
@@ -2690,8 +2708,10 @@ export default class TicketsDataProvider {
         const subRes = await postBatch(currentIds);
         res.push(...subRes.value);
       } catch (error) {
-        logger.error(`error populating workitems array`);
-        logger.error(JSON.stringify(error));
+        // JSON.stringify(error) on an AxiosError calls its own .toJSON(), which serializes
+        // config.auth.password / config.headers.Authorization — the PAT, in plaintext. Pass
+        // the error as meta instead and let the logger's redact format scrub it.
+        logger.error(`error populating workitems array`, error);
         return [];
       }
     }
@@ -2825,8 +2845,9 @@ export default class TicketsDataProvider {
       );
       return attachmentList;
     } catch (e) {
-      logger.error(`error fetching attachments for work item ${id}`);
-      logger.error(`${JSON.stringify(e)}`);
+      // JSON.stringify(e) on an Error returns "{}" — own enumerable props only, message/stack
+      // are non-enumerable — so this logged literally nothing useful. Pass it as meta instead.
+      logger.error(`error fetching attachments for work item ${id}`, e);
       return [];
     }
   }
@@ -3143,11 +3164,9 @@ export default class TicketsDataProvider {
       return { tree1: tree1Node, tree2: tree2Node };
     } catch (err: any) {
       logger.error(
-        `Error occurred while constructing the query list ${err.message} with query ${JSON.stringify(
-          rootQuery,
-        )}`,
+        `Error occurred while constructing the query list with query ${JSON.stringify(rootQuery)}`,
+        err,
       );
-      logger.error(`Error stack ${err.message}`);
     }
   }
 

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

@@ -36,7 +36,9 @@ describe('JfrogDataProvider', () => {
         `${mockOrgUrl}${mockTeamProject}/_apis/serviceendpoint/endpoints/${mockConnectionId}?api-version=7.1`,
         mockTfsToken
       );
-      expect(logger.debug).toHaveBeenCalledWith(`service connection url "${mockResponse.url}"`);
+      // The log used JSON.stringify(url), which wraps a plain string in quotes for no reason —
+      // fixed to interpolate the string directly (see docgen-log-redaction / Phase 2).
+      expect(logger.debug).toHaveBeenCalledWith(`service connection url ${mockResponse.url}`);
       expect(result).toBe(mockResponse.url);
     });
 

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

@@ -6027,8 +6027,12 @@ describe('ResultDataProvider', () => {
         resultDataProvider.getCombinedResultsSummary(mockTestPlanId, mockProjectName)
       ).rejects.toThrow('boom');
 
-      expect(logger.error).toHaveBeenCalledWith('Error during getCombinedResultsSummary: boom');
-      expect(logger.error).toHaveBeenCalledWith('Response Data: {"detail":"bad"}');
+      // Was two separate calls (message, then the response body) — consolidated into one
+      // record with the response summary as meta (docgen-log-redaction / Phase 2/4).
+      expect(logger.error).toHaveBeenCalledWith('Error during getCombinedResultsSummary: boom', {
+        responseSummary: '{"detail":"bad"}',
+      });
+      expect(logger.error).toHaveBeenCalledTimes(1);
     });
   });
 

package/src/tests/modules/ticketsDataProvider.historical.test.ts

@@ -1162,73 +1162,158 @@ describe('TicketsDataProvider historical queries', () => {
     ).toBe(true);
   });
 
-  it('GetHistoricalQueryResults drops only the specific field ADO names in TF51535, keeping Custom.TestPhase when only Elisra.TestPhase is undefined for this project', async () => {
+  it('GetHistoricalQueryResults resolves the real Test Phase reference name from the project\'s own field list instead of guessing', async () => {
     const asOfIso = '2026-02-01T00:00:00.000Z';
-    // 205 ids -> 2 chunks (200 + 5), both dispatched with the full field list
-    // near-simultaneously — this proves the retry is decided per-call, not
-    // from the shared override flag, since both chunks fail before either
-    // one sets it.
-    const allIds = Array.from({ length: 205 }, (_, idx) => idx + 1);
 
     (TFSServices.getItemContent as jest.Mock).mockImplementation(
       async (url: string, _pat: string, method?: string, data?: any) => {
-        if (url.includes('/_apis/wit/queries/q-unknown-field') && url.includes('api-version=7.1')) {
-          return { name: 'Unknown Field Q', wiql: 'SELECT [System.Id] FROM WorkItems' };
+        if (url.includes('/_apis/wit/queries/q-resolve-field') && url.includes('api-version=7.1')) {
+          return { name: 'Resolve Field Q', wiql: 'SELECT [System.Id] FROM WorkItems' };
         }
         if (url.includes('/_apis/wit/wiql?') && method === 'post') {
-          return { workItems: allIds.map((id) => ({ id })) };
+          return { workItems: [{ id: 501 }] };
+        }
+        if (url.endsWith('/_apis/wit/fields?api-version=7.1')) {
+          // Neither Elisra.TestPhase nor Custom.TestPhase — a third,
+          // project-specific reference name, discovered only by friendly
+          // name ("Test Phase").
+          return {
+            value: [
+              { name: 'Title', referenceName: 'System.Title' },
+              { name: 'Test Phase', referenceName: 'MyCompany.QaPhase' },
+            ],
+          };
         }
         if (url.includes('/_apis/wit/workitemsbatch') && method === 'post') {
           if (data?.$expand === 'Relations') {
-            return {
-              value: (Array.isArray(data?.ids) ? data.ids : []).map((id: number) => ({ id, relations: [] })),
-            };
+            return { value: [{ id: 501, relations: [] }] };
           }
-          if (Array.isArray(data?.fields) && data.fields.includes('Elisra.TestPhase')) {
-            throw {
-              response: {
-                status: 400,
-                data: { message: "TF51535: Cannot find field 'Elisra.TestPhase'." },
+          expect(data.fields).toEqual(expect.arrayContaining(['MyCompany.QaPhase']));
+          expect(data.fields).not.toEqual(
+            expect.arrayContaining(['Elisra.TestPhase', 'Custom.TestPhase']),
+          );
+          return {
+            value: [
+              {
+                id: 501,
+                rev: 1,
+                fields: {
+                  'System.WorkItemType': 'Test Case',
+                  'System.Title': 'Resolved',
+                  'System.State': 'Active',
+                  'System.ChangedDate': asOfIso,
+                  'MyCompany.QaPhase': 'FAT',
+                },
               },
-            };
+            ],
+          };
+        }
+        throw new Error(`unexpected URL: ${url}`);
+      },
+    );
+
+    const result = await provider.GetHistoricalQueryResults('q-resolve-field', project, asOfIso);
+
+    expect(result.total).toBe(1);
+    const fieldsListCalls = (TFSServices.getItemContent as jest.Mock).mock.calls.filter((call) =>
+      String(call[0]).endsWith('/_apis/wit/fields?api-version=7.1'),
+    );
+    expect(fieldsListCalls).toHaveLength(1);
+  });
+
+  it('GetHistoricalQueryResults reuses the resolved field across baseline and compareTo without re-querying fields', async () => {
+    const baselineIso = '2026-02-20T00:00:00.000Z';
+    const compareIso = '2026-02-25T00:00:00.000Z';
+    let fieldsListCallCount = 0;
+
+    (TFSServices.getItemContent as jest.Mock).mockImplementation(
+      async (url: string, _pat: string, method?: string, data?: any) => {
+        if (url.includes('/_apis/wit/queries/q-cache-field') && url.includes('api-version=7.1')) {
+          return { name: 'Cache Field Q', wiql: 'SELECT [System.Id] FROM WorkItems' };
+        }
+        if (url.includes('/_apis/wit/wiql?') && method === 'post') {
+          return { workItems: [{ id: 601 }] };
+        }
+        if (url.endsWith('/_apis/wit/fields?api-version=7.1')) {
+          fieldsListCallCount += 1;
+          return { value: [{ name: 'Test Phase', referenceName: 'Custom.TestPhase' }] };
+        }
+        if (url.includes('/_apis/wit/workitemsbatch') && method === 'post') {
+          if (data?.$expand === 'Relations') {
+            return { value: [{ id: 601, relations: [] }] };
           }
-          // Custom.TestPhase is the real field on this project and must
-          // still be requested — only the unrecognized alias should be
-          // dropped, not every optional field.
-          expect(data.fields).toEqual(expect.arrayContaining(['Custom.TestPhase']));
-          expect(data.fields).not.toEqual(expect.arrayContaining(['Elisra.TestPhase']));
           return {
-            value: (Array.isArray(data?.ids) ? data.ids : []).map((id: number) => ({
-              id,
-              rev: 1,
-              fields: {
-                'System.WorkItemType': 'Test Case',
-                'System.Title': `Test ${id}`,
-                'System.State': 'Active',
-                'System.ChangedDate': asOfIso,
-                'Custom.TestPhase': 'FAT',
+            value: [
+              {
+                id: 601,
+                rev: 1,
+                fields: {
+                  'System.WorkItemType': 'Test Case',
+                  'System.Title': 'Cached',
+                  'System.State': 'Active',
+                  'System.ChangedDate': data.asOf,
+                },
               },
-            })),
+            ],
           };
         }
         throw new Error(`unexpected URL: ${url}`);
       },
     );
 
-    const result = await provider.GetHistoricalQueryResults('q-unknown-field', project, asOfIso);
+    await provider.CompareHistoricalQueryResults('q-cache-field', project, baselineIso, compareIso);
 
-    // Every id came back — nothing fell to the 2xN per-item fallback, which
-    // would have thrown on any call not covered by the handler above.
-    expect(result.total).toBe(205);
-    const fieldsCallsWithElisraAlias = (TFSServices.getItemContent as jest.Mock).mock.calls.filter(
-      (call) => Array.isArray(call[3]?.fields) && call[3].fields.includes('Elisra.TestPhase'),
+    // Baseline and compareTo run concurrently against the same provider
+    // instance — the field list is fetched once, not once per snapshot.
+    expect(fieldsListCallCount).toBe(1);
+  });
+
+  it('GetHistoricalQueryResults omits Test Phase entirely when the project defines neither known name, without failing the batch', async () => {
+    const asOfIso = '2026-03-01T00:00:00.000Z';
+
+    (TFSServices.getItemContent as jest.Mock).mockImplementation(
+      async (url: string, _pat: string, method?: string, data?: any) => {
+        if (url.includes('/_apis/wit/queries/q-no-field') && url.includes('api-version=7.1')) {
+          return { name: 'No Field Q', wiql: 'SELECT [System.Id] FROM WorkItems' };
+        }
+        if (url.includes('/_apis/wit/wiql?') && method === 'post') {
+          return { workItems: [{ id: 701 }] };
+        }
+        if (url.endsWith('/_apis/wit/fields?api-version=7.1')) {
+          return { value: [{ name: 'Title', referenceName: 'System.Title' }] };
+        }
+        if (url.includes('/_apis/wit/workitemsbatch') && method === 'post') {
+          if (data?.$expand === 'Relations') {
+            return { value: [{ id: 701, relations: [] }] };
+          }
+          expect(data.fields).not.toEqual(
+            expect.arrayContaining(['Elisra.TestPhase', 'Custom.TestPhase']),
+          );
+          return {
+            value: [
+              {
+                id: 701,
+                rev: 1,
+                fields: {
+                  'System.WorkItemType': 'Bug',
+                  'System.Title': 'No test phase field',
+                  'System.State': 'Active',
+                  'System.ChangedDate': asOfIso,
+                },
+              },
+            ],
+          };
+        }
+        throw new Error(`unexpected URL: ${url}`);
+      },
     );
-    // Both chunks start with the full field list before the override is set,
-    // so both legitimately fail once and both must retry — not just one.
-    expect(fieldsCallsWithElisraAlias).toHaveLength(2);
+
+    const result = await provider.GetHistoricalQueryResults('q-no-field', project, asOfIso);
+
+    expect(result.total).toBe(1);
     expect(
       (logger.warn as jest.Mock).mock.calls.some((call) =>
-        String(call[0]).includes("field 'Elisra.TestPhase' not defined for this project"),
+        String(call[0]).includes("no Test Phase field defined for project"),
       ),
     ).toBe(true);
   });