@elisra-devops/docgen-data-provider 1.140.0 → 1.142.0

package/src/modules/TicketsDataProvider.ts

@@ -10,6 +10,7 @@ import { TestSteps } from '../models/tfs-data';
 import TestStepParserHelper from '../utils/testStepParserHelper';
 
 import logger from '../utils/logger';
+import { describeError } from '../helpers/requestContext';
 const pLimit = require('p-limit');
 
 type FallbackFetchOutcome = {
@@ -491,7 +492,7 @@ export default class TicketsDataProvider {
           break;
       }
     } catch (err: any) {
-      logger.error(`Error occurred during fetching shared queries: ${err.message}`);
+      logger.error('Error occurred during fetching shared queries:', describeError(err));
       throw err;
     }
   }
@@ -527,7 +528,7 @@ export default class TicketsDataProvider {
           })
       );
     } catch (err: any) {
-      logger.error(`Error occurred during fetching fields by type: ${err.message}`);
+      logger.error('Error occurred during fetching fields by type:', describeError(err));
       throw err;
     }
   }
@@ -558,7 +559,7 @@ export default class TicketsDataProvider {
       }
       return { types, states: Array.from(stateSet) };
     } catch (err: any) {
-      logger.error(`Error fetching work item type states: ${err.message}`);
+      logger.error('Error fetching work item type states:', describeError(err));
       throw err;
     }
   }
@@ -783,11 +784,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;
     }
   }
@@ -1288,7 +1287,7 @@ export default class TicketsDataProvider {
           break;
       }
     } catch (err: any) {
-      logger.error(`Could not fetch query results for ${wiqlHref}: ${err.message}`);
+      logger.error(`Could not fetch query results for ${wiqlHref}:`, describeError(err));
     }
   }
 
@@ -1664,7 +1663,7 @@ export default class TicketsDataProvider {
       }
       return [...workItemsResultMap.values()];
     } catch (error: any) {
-      logger.error(`could not parse requested flat query: ${error.message}`);
+      logger.error('could not parse requested flat query:', describeError(error));
     }
   }
 
@@ -2697,8 +2696,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 [];
       }
     }
@@ -2708,8 +2709,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 [];
       }
     }
@@ -2843,8 +2846,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 [];
     }
   }
@@ -3161,11 +3165,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}`);
     }
   }
 
@@ -3561,7 +3563,7 @@ export default class TicketsDataProvider {
 
       item.fields = { ...parsedFields };
     } catch (err: any) {
-      logger.error(`Cannot filter columns: ${err.message}`);
+      logger.error('Cannot filter columns:', describeError(err));
       throw err;
     }
   }
@@ -3616,7 +3618,7 @@ export default class TicketsDataProvider {
 
       return workItemTypesWithIcons;
     } catch (err: any) {
-      logger.error(`Error occurred during fetching work item types: ${err.message}`);
+      logger.error('Error occurred during fetching work item types:', describeError(err));
       throw err;
     }
   }
@@ -3769,7 +3771,7 @@ export default class TicketsDataProvider {
             categorizedRequirements['Precedence and Criticality of Requirements'].push(requirementItem);
           }
         } catch (err: any) {
-          logger.warn(`Could not fetch work item ${workItemId}: ${err.message}`);
+          logger.warn(`Could not fetch work item ${workItemId}:`, describeError(err));
         }
       }
 
@@ -3791,7 +3793,7 @@ export default class TicketsDataProvider {
         totalCount: workItemIds.length,
       };
     } catch (err: any) {
-      logger.error(`Could not fetch categorized requirements: ${err.message}`);
+      logger.error('Could not fetch categorized requirements:', describeError(err));
       throw err;
     }
   }
@@ -3886,7 +3888,7 @@ export default class TicketsDataProvider {
           const relations = qr?.workItemRelations || [];
           result['req-test'] = await resolveQuerySides(cols, relations, true);
         } catch (err: any) {
-          logger.error(`GetTraceColumnsByType[req-test] failed: ${err.message}`);
+          logger.error('GetTraceColumnsByType[req-test] failed:', describeError(err));
           result['req-test'] = { Requirement: [], 'Test Case': [] };
         }
       }
@@ -3898,14 +3900,14 @@ export default class TicketsDataProvider {
           const relations = qr?.workItemRelations || [];
           result['test-req'] = await resolveQuerySides(cols, relations, false);
         } catch (err: any) {
-          logger.error(`GetTraceColumnsByType[test-req] failed: ${err.message}`);
+          logger.error('GetTraceColumnsByType[test-req] failed:', describeError(err));
           result['test-req'] = { Requirement: [], 'Test Case': [] };
         }
       }
 
       return result;
     } catch (err: any) {
-      logger.error(`GetTraceColumnsByType failed: ${err.message}`);
+      logger.error('GetTraceColumnsByType failed:', describeError(err));
       return {};
     }
   }

package/src/tests/helpers/requestContext.test.ts

@@ -0,0 +1,202 @@
+import {
+  sanitizeUrl,
+  summarizeBody,
+  summarizeResponse,
+  buildAdoRequestContext,
+  annotateAdoError,
+  maskWiqlLiterals,
+} from '../../helpers/requestContext';
+
+describe('maskWiqlLiterals', () => {
+  it('replaces every quoted literal with its length', () => {
+    expect(maskWiqlLiterals("a = 'xy' and b = ''")).toBe("a = '[2 chars]' and b = '[0 chars]'");
+  });
+});
+
+describe('sanitizeUrl', () => {
+  it('returns undefined for a missing or empty url', () => {
+    expect(sanitizeUrl(undefined)).toBeUndefined();
+    expect(sanitizeUrl('')).toBeUndefined();
+  });
+
+  it('keeps a normal ADO url intact', () => {
+    const url = 'https://dev.azure.com/org/proj/_apis/wit/queries/abc?$depth=1&api-version=7.0';
+    expect(sanitizeUrl(url)).toBe(url);
+  });
+
+  it('strips credentials embedded in the url', () => {
+    const out = sanitizeUrl('https://user:s3cret@dev.azure.com/org/_apis/projects');
+    expect(out).not.toContain('s3cret');
+    expect(out).not.toContain('user');
+    expect(out).toContain('dev.azure.com/org/_apis/projects');
+  });
+
+  it('masks sensitive query parameter values but keeps ordinary ones', () => {
+    const out = sanitizeUrl('https://host/api?access_token=abc123&top=10&sig=zzz&keywords=release')!;
+    expect(out).not.toContain('abc123');
+    expect(out).not.toContain('zzz');
+    expect(out).toContain('top=10');
+    expect(out).toContain('keywords=release');
+  });
+
+  it('leaves non-sensitive parameters byte-identical when masking another', () => {
+    expect(sanitizeUrl('https://h/api?$filter=a%20b&token=x&q=a+b')).toBe('https://h/api?$filter=a%20b&token=[REDACTED]&q=a+b');
+  });
+
+  it('passes a non-absolute url through, bounded', () => {
+    expect(sanitizeUrl('/relative/path')).toBe('/relative/path');
+    expect(sanitizeUrl('x'.repeat(5000))!.length).toBeLessThanOrEqual(1001);
+  });
+});
+
+describe('summarizeBody', () => {
+  it('never describes a GET body', () => {
+    expect(summarizeBody({ query: 'SELECT 1' }, 'get')).toBeUndefined();
+    expect(summarizeBody({ query: 'SELECT 1' }, 'HEAD')).toBeUndefined();
+  });
+
+  it('returns undefined for an empty body — the default `{}` callers pass', () => {
+    expect(summarizeBody({}, 'post')).toBeUndefined();
+    expect(summarizeBody([], 'post')).toBeUndefined();
+    expect(summarizeBody(null, 'post')).toBeUndefined();
+    expect(summarizeBody('', 'post')).toBeUndefined();
+  });
+
+  it('keeps a WIQL-style body so the failing query is visible', () => {
+    const out = summarizeBody({ query: "SELECT [System.Id] FROM WorkItems WHERE [System.TeamProject] = 'P'" }, 'post')!;
+    expect(out).toContain('SELECT [System.Id] FROM WorkItems');
+    expect(out).toContain("[System.TeamProject] = '[1 chars]'");
+    expect(out).not.toContain("= 'P'");
+  });
+
+  it('masks WIQL literals (incl. escaped quotes) but keeps fields, numbers and macros', () => {
+    const out = summarizeBody({ query: "SELECT [Id] FROM WorkItems WHERE [Title] = 'it''s secret' AND [Assigned] = @Me AND [Id] > 42" }, 'post')!;
+    expect(out).not.toContain('secret');
+    expect(out).toContain("[Title] = '[12 chars]'");
+    expect(out).toContain('@Me');
+    expect(out).toContain('> 42');
+  });
+
+  it('keeps an id-list body', () => {
+    expect(summarizeBody({ ids: [1, 2, 3], fields: ['System.Title'] }, 'post')).toBe(
+      '{"ids":[1,2,3],"fields":["System.Title"]}'
+    );
+  });
+
+  it('redacts credential-looking keys at any depth', () => {
+    const out = summarizeBody({ query: 'q', auth: { token: 'tok-123', password: 'pw-456' }, pat: 'pat-789' }, 'post')!;
+    expect(out).not.toContain('tok-123');
+    expect(out).not.toContain('pw-456');
+    expect(out).not.toContain('pat-789');
+    expect(out).toContain('[REDACTED]');
+    expect(out).toContain('"query":"q"');
+  });
+
+  it('JSON-Patch bodies keep op + path only — field values are dropped', () => {
+    const patch = [
+      { op: 'add', path: '/fields/System.Title', value: 'Highly classified title' },
+      { op: 'replace', path: '/fields/System.Description', value: { html: '<p>secret</p>' } },
+    ];
+    const out = summarizeBody(patch, 'patch')!;
+    expect(out).toContain('json-patch (2 ops, values omitted)');
+    expect(out).toContain('add /fields/System.Title');
+    expect(out).toContain('replace /fields/System.Description');
+    expect(out).not.toContain('classified');
+    expect(out).not.toContain('secret');
+  });
+
+  it('bounds a long string value and the whole body', () => {
+    const one = summarizeBody({ query: 'x'.repeat(5000) }, 'post')!;
+    expect(one.length).toBeLessThan(700);
+    const many = summarizeBody(Object.fromEntries(Array.from({ length: 300 }, (_, i) => [`k${i}`, 'v'.repeat(40)])), 'post')!;
+    expect(many.length).toBeLessThanOrEqual(2001);
+  });
+
+  it('caps a very long array', () => {
+    const out = summarizeBody({ ids: Array.from({ length: 500 }, (_, i) => i) }, 'post')!;
+    expect(out).toContain('more');
+  });
+
+  it('describes non-JSON bodies by type and size only', () => {
+    expect(summarizeBody(Buffer.from('abcdef'), 'post')).toBe('[binary, 6 bytes]');
+    expect(summarizeBody('not json at all', 'post')).toBe('[text, 15 chars]');
+    expect(summarizeBody(42, 'post')).toBe('[number]');
+    expect(summarizeBody({ pipe: () => undefined }, 'post')).toBe('[stream]');
+  });
+
+  it('parses a JSON string body and summarizes it like an object', () => {
+    expect(summarizeBody('{"query":"q"}', 'post')).toBe('{"query":"q"}');
+  });
+
+  it('never throws on a body it cannot serialize', () => {
+    expect(summarizeBody({ n: BigInt(1) }, 'post')).toBe('[unserializable body]');
+    const circular: Record<string, unknown> = { a: 1 };
+    circular.self = circular;
+    expect(() => summarizeBody(circular, 'post')).not.toThrow();
+  });
+});
+
+describe('summarizeResponse', () => {
+  it('prefers the server message (ADO puts its explanation there)', () => {
+    expect(summarizeResponse({ message: 'TF401232: Work item 5 does not exist', typeName: 'x' })).toBe(
+      'TF401232: Work item 5 does not exist'
+    );
+  });
+
+  it('truncates a text response (e.g. an HTML error page) to 200 chars', () => {
+    expect(summarizeResponse('<html>'.repeat(200))!.length).toBeLessThanOrEqual(201);
+  });
+
+  it('falls back to a redacted, bounded JSON dump when there is no message', () => {
+    const out = summarizeResponse({ code: 1, token: 'leak-me' })!;
+    expect(out).not.toContain('leak-me');
+    expect(out).toContain('"code":1');
+  });
+
+  it('does not walk a stream response', () => {
+    expect(summarizeResponse({ pipe: () => undefined, socket: { a: 1 } })).toBe('[stream]');
+  });
+
+  it('ignores a missing or binary response', () => {
+    expect(summarizeResponse(undefined)).toBeUndefined();
+    expect(summarizeResponse(Buffer.from('x'))).toBeUndefined();
+  });
+});
+
+describe('buildAdoRequestContext', () => {
+  it('describes a failed GET with method, status, attempt and the server message', () => {
+    const err = { response: { status: 404, data: { message: 'not found' } } };
+    expect(buildAdoRequestContext(err, { method: 'get', url: 'https://h/_apis/x' }, 2)).toEqual({
+      method: 'GET',
+      url: 'https://h/_apis/x',
+      status: 404,
+      attempt: 2,
+      responseExcerpt: 'not found',
+    });
+  });
+
+  it('includes a summarized body for a POST and omits fields it does not have', () => {
+    const ctx = buildAdoRequestContext(new Error('boom'), { method: 'post', url: 'https://h/wiql', data: { query: 'q' } });
+    expect(ctx).toEqual({ method: 'POST', url: 'https://h/wiql', requestBody: '{"query":"q"}' });
+  });
+
+  it('falls back to the axios error config when the request is not described explicitly', () => {
+    const ctx = buildAdoRequestContext({ config: { method: 'put', url: 'https://h/y' } }, {});
+    expect(ctx.method).toBe('PUT');
+    expect(ctx.url).toBe('https://h/y');
+  });
+});
+
+describe('annotateAdoError', () => {
+  it('attaches the context as an enumerable property winston will merge onto the record', () => {
+    const err = annotateAdoError(new Error('x'), { method: 'GET', url: 'https://h/z' });
+    expect(Object.keys(err)).toContain('adoRequest');
+    expect((err as any).adoRequest.url).toBe('https://h/z');
+  });
+
+  it('never throws on a frozen or non-object error', () => {
+    expect(() => annotateAdoError(Object.freeze(new Error('x')), { url: 'u' })).not.toThrow();
+    expect(() => annotateAdoError('a string' as any, { url: 'u' })).not.toThrow();
+    expect(() => annotateAdoError(undefined as any, { url: 'u' })).not.toThrow();
+  });
+});

package/src/tests/helpers/tfs.test.ts

@@ -1089,3 +1089,89 @@ describe('TFSServices', () => {
     });
   });
 });
+
+describe('TFSServices request-context annotation', () => {
+  // Math.random is pinned and setTimeout collapsed so a retried failure doesn't slow the suite.
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockAxiosInstance.request.mockReset();
+  });
+
+  const notFound = () => {
+    const e: any = new Error('Request failed with status code 404');
+    e.response = { status: 404, data: { message: 'TF401232: Work item 5 does not exist' } };
+    return e;
+  };
+
+  it('annotates the thrown error with the request even when printError is false, without logging', async () => {
+    mockAxiosInstance.request.mockRejectedValue(notFound());
+
+    const caught = await TFSServices.getItemContent('https://dev.azure.com/org/_apis/wit/queries/q1', 'pat', 'get', {}, {}, false).catch(
+      (e) => e
+    );
+
+    expect(caught.adoRequest).toEqual({
+      method: 'GET',
+      url: 'https://dev.azure.com/org/_apis/wit/queries/q1',
+      status: 404,
+      attempt: 1,
+      responseExcerpt: 'TF401232: Work item 5 does not exist',
+    });
+    expect(logger.error).not.toHaveBeenCalled();
+  });
+
+  it('with printError, also emits the one "ADO request failed" record carrying the same context', async () => {
+    mockAxiosInstance.request.mockRejectedValue(notFound());
+
+    await TFSServices.getItemContent('https://dev.azure.com/org/_apis/x', 'pat').catch(() => undefined);
+
+    expect(logger.error).toHaveBeenCalledTimes(1);
+    expect(logger.error).toHaveBeenCalledWith(
+      'ADO request failed',
+      expect.objectContaining({
+        adoRequest: expect.objectContaining({ method: 'GET', url: 'https://dev.azure.com/org/_apis/x', status: 404 }),
+      })
+    );
+  });
+
+  it('never leaks the PAT: credentials are applied to the axios config, not the description', async () => {
+    mockAxiosInstance.request.mockRejectedValue(notFound());
+
+    const caught = await TFSServices.getItemContent('https://dev.azure.com/org/_apis/x', 'super-secret-pat', 'get', {}, {}, false).catch(
+      (e) => e
+    );
+
+    expect(JSON.stringify(caught.adoRequest)).not.toContain('super-secret-pat');
+  });
+
+  it('postRequest describes a JSON-Patch body by op + path only', async () => {
+    mockAxiosInstance.request.mockRejectedValue(notFound());
+
+    const caught = await TFSServices.postRequest(
+      'https://dev.azure.com/org/_apis/wit/workitems/9',
+      'pat',
+      'PATCH',
+      [{ op: 'add', path: '/fields/System.Title', value: 'confidential title' }]
+    ).catch((e) => e);
+
+    expect(caught.adoRequest.method).toBe('PATCH');
+    expect(caught.adoRequest.requestBody).toContain('add /fields/System.Title');
+    expect(caught.adoRequest.requestBody).not.toContain('confidential');
+  });
+
+  it('getJfrogRequest annotates too', async () => {
+    mockAxiosInstance.request.mockRejectedValue(notFound());
+
+    const caught = await TFSServices.getJfrogRequest('https://jfrog.example/api/x').catch((e) => e);
+
+    expect(caught.adoRequest).toEqual(expect.objectContaining({ method: 'GET', url: 'https://jfrog.example/api/x', status: 404 }));
+  });
+
+  it('downloadZipFile annotates the error it rethrows', async () => {
+    mockAxiosInstance.request.mockRejectedValue(notFound());
+
+    const caught = await TFSServices.downloadZipFile('https://dev.azure.com/org/file.zip', 'pat').catch((e) => e);
+
+    expect(caught.adoRequest).toEqual(expect.objectContaining({ method: 'GET', url: 'https://dev.azure.com/org/file.zip', status: 404 }));
+  });
+});

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);
     });
 
@@ -160,7 +162,8 @@ describe('JfrogDataProvider', () => {
       ).rejects.toThrow('JFrog API error');
 
       expect(logger.error).toHaveBeenCalledWith(
-        `Error occurred during querying JFrog using: JFrog API error`
+        'Error occurred during querying JFrog using:',
+        expect.objectContaining({ message: 'JFrog API error' })
       );
     });
   });

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

@@ -5324,7 +5324,8 @@ describe('ResultDataProvider', () => {
       );
 
       expect(logger.error).toHaveBeenCalledWith(
-        expect.stringContaining('Could not append related work item to test case 999')
+        'Could not append related work item to test case 999:',
+        expect.objectContaining({ message: 'network' })
       );
     });
   });
@@ -6027,8 +6028,14 @@ 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:', {
+        message: 'boom',
+        stack: expect.any(String),
+        responseSummary: '{"detail":"bad"}',
+      });
+      expect(logger.error).toHaveBeenCalledTimes(1);
     });
   });
 

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

@@ -367,7 +367,8 @@ describe('GitDataProvider - GetFileFromGitRepo', () => {
 
     // Assert
     expect(logger.warn).toHaveBeenCalledWith(
-      expect.stringContaining(`File ${mockFileName} could not be read: ${mockError.message}`)
+      `File ${mockFileName} could not be read:`,
+      expect.objectContaining({ message: mockError.message })
     );
     expect(result).toBeUndefined();
   });

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

@@ -305,7 +305,8 @@ describe('PipelinesDataProvider', () => {
         null
       );
       expect(logger.error).toHaveBeenCalledWith(
-        `Could not fetch Pipeline Run History: ${expectedError.message}`
+        'Could not fetch Pipeline Run History:',
+        expect.objectContaining({ message: expectedError.message })
       );
       expect(result).toBeUndefined();
     });

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

@@ -105,7 +105,10 @@ describe('TestDataProvider', () => {
 
       // Act & Assert
       await expect(invokeFetchWithCache(testDataProvider, mockUrl)).rejects.toThrow('API call failed');
-      expect(logger.error).toHaveBeenCalledWith(`Error fetching ${mockUrl}: API call failed`);
+      expect(logger.error).toHaveBeenCalledWith(
+        `Error fetching ${mockUrl}:`,
+        expect.objectContaining({ message: 'API call failed' })
+      );
     });
   });
 

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

@@ -1108,7 +1108,7 @@ describe('TicketsDataProvider', () => {
       expect(() =>
         (ticketsDataProvider as any).filterFieldsByColumns(item, columnsToFilterMap, resultedRefNameMap),
       ).toThrow();
-      expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('Cannot filter columns'));
+      expect(logger.error).toHaveBeenCalledWith('Cannot filter columns:', expect.objectContaining({ message: expect.any(String) }));
     });
   });
 
@@ -2779,7 +2779,7 @@ describe('TicketsDataProvider', () => {
       expect(res.categories['Security and Privacy Requirements']).toHaveLength(1);
       expect(res.categories['Precedence and Criticality of Requirements']).toHaveLength(1);
       expect(res.categories['Other Requirements']).toHaveLength(1);
-      expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('Could not fetch work item 13'));
+      expect(logger.warn).toHaveBeenCalledWith('Could not fetch work item 13:', expect.objectContaining({ message: 'boom' }));
     });
 
     it('should extract IDs from workItemRelations for OneHop queries', async () => {