anonymizer/test/openai-compatible.test.ts

import { describe, it, expect, vi, afterEach } from 'vitest';
import { openAICompatibleProvider } from '../src/index.js';

const opts = { baseUrl: 'https://api.example.com/v1', apiKey: 'k', model: 'm' };

function mockFetchJson(content: unknown) {
  return vi.fn().mockResolvedValue({
    ok: true,
    json: async () => ({ choices: [{ message: { content: JSON.stringify(content) } }] }),
  });
}

afterEach(() => {
  vi.unstubAllGlobals();
});

describe('openAICompatibleProvider', () => {
  it('isConfigured() reflects whether baseUrl/apiKey/model are present', () => {
    expect(openAICompatibleProvider(opts).isConfigured()).toBe(true);
    expect(openAICompatibleProvider({ ...opts, apiKey: '' }).isConfigured()).toBe(false);
  });

  it('anonymize() parses {texte_anonymise, mapping} and posts temperature 0, no response_format by default', async () => {
    const fetchMock = mockFetchJson({ texte_anonymise: '[EMAIL_1]', mapping: { '[EMAIL_1]': 'a@b.ch' } });
    vi.stubGlobal('fetch', fetchMock);

    const r = await openAICompatibleProvider(opts).anonymize('a@b.ch');
    expect(r).toEqual({ anon: '[EMAIL_1]', mapping: { '[EMAIL_1]': 'a@b.ch' }, legend: {} });

    const [url, init] = fetchMock.mock.calls[0];
    expect(url).toBe('https://api.example.com/v1/chat/completions');
    const body = JSON.parse(init.body);
    expect(body.temperature).toBe(0);
    expect(body.response_format).toBeUndefined(); // omitted by default (Infomaniak rejects json_object)
    expect(init.headers.Authorization).toBe('Bearer k');
  });

  it('sends response_format only when the option is provided', async () => {
    const fetchMock = mockFetchJson({ texte_anonymise: 'x', mapping: {} });
    vi.stubGlobal('fetch', fetchMock);

    await openAICompatibleProvider({ ...opts, responseFormat: { type: 'json_object' } }).anonymize('x');
    const body = JSON.parse(fetchMock.mock.calls[0][1].body);
    expect(body.response_format).toEqual({ type: 'json_object' });
  });

  it('parses JSON wrapped in a markdown code fence (lenient parsing)', async () => {
    const fenced = '```json\n{"texte_anonymise":"[EMAIL_1]","mapping":{"[EMAIL_1]":"a@b.ch"}}\n```';
    const fetchMock = vi.fn().mockResolvedValue({
      ok: true,
      json: async () => ({ choices: [{ message: { content: fenced } }] }),
    });
    vi.stubGlobal('fetch', fetchMock);

    const r = await openAICompatibleProvider(opts).anonymize('a@b.ch');
    expect(r).toEqual({ anon: '[EMAIL_1]', mapping: { '[EMAIL_1]': 'a@b.ch' }, legend: {} });
  });

  it('parses the model legende into result.legend, keeping only string values', async () => {
    const fetchMock = mockFetchJson({
      texte_anonymise: '[PER_1.NOM:M]',
      mapping: { '[PER_1.NOM:M]': 'Alain Jaccard' },
      legende: { PER: 'Personne', NOM: 'Nom de famille', M: 'Masculin', BAD: 42 },
    });
    vi.stubGlobal('fetch', fetchMock);

    const r = await openAICompatibleProvider(opts).anonymize('Alain Jaccard');
    expect(r.legend).toEqual({ PER: 'Personne', NOM: 'Nom de famille', M: 'Masculin' });
  });

  it('anonymizeBatch() returns {segments, mapping} and includes used ids in the prompt', async () => {
    const fetchMock = mockFetchJson({ segments: ['[PER_2.NOM:M]'], mapping: { '[PER_2.NOM:M]': 'Bob' } });
    vi.stubGlobal('fetch', fetchMock);

    const r = await openAICompatibleProvider(opts).anonymizeBatch(['Bob'], ['[PER_1.NOM:M]']);
    expect(r.segments).toEqual(['[PER_2.NOM:M]']);

    const system = JSON.parse(fetchMock.mock.calls[0][1].body).messages[0].content;
    expect(system).toContain('[PER_1.NOM:M]');
  });

  it('anonymizeInConversation includes used-ids + history, and the mapping ONLY when opted in', async () => {
    const content = JSON.stringify({
      texte_anonymise: '[PER_2.NOM:F]',
      mapping: { '[PER_2.NOM:F]': 'X' },
      legende: {},
    });
    const fetchMock = vi
      .fn()
      .mockResolvedValue({ ok: true, json: async () => ({ choices: [{ message: { content } }] }) });
    vi.stubGlobal('fetch', fetchMock);
    const ctx = {
      history: ['Je suis [PER_1.NOM:F]'],
      legend: { PER: 'Personne' },
      usedIds: ['[PER_1.NOM:F]'],
      mapping: { '[PER_1.NOM:F]': 'Nora Steiner' },
    };

    // default: real values (mapping) are NOT sent
    await openAICompatibleProvider(opts).anonymizeInConversation!('x', ctx);
    let system = JSON.parse(fetchMock.mock.calls[0][1].body).messages[0].content;
    expect(system).toContain('[PER_1.NOM:F]'); // used-ids present
    expect(system).toContain('Je suis [PER_1.NOM:F]'); // anonymized history present
    expect(system).not.toContain('Nora Steiner'); // real value withheld by default

    // opted in: the mapping (real value) is included
    await openAICompatibleProvider({ ...opts, includeMappingInContext: true }).anonymizeInConversation!(
      'x',
      ctx,
    );
    system = JSON.parse(fetchMock.mock.calls[1][1].body).messages[0].content;
    expect(system).toContain('Nora Steiner');
  });

  it('throws on a non-OK HTTP status (no retry when retries: 0)', async () => {
    const fetchMock = vi.fn().mockResolvedValue({ ok: false, status: 500 });
    vi.stubGlobal('fetch', fetchMock);
    await expect(openAICompatibleProvider({ ...opts, retries: 0 }).anonymize('x')).rejects.toThrow(
      'LLM_HTTP_500',
    );
    expect(fetchMock).toHaveBeenCalledTimes(1);
  });

  it('throws on a malformed response shape', async () => {
    vi.stubGlobal('fetch', mockFetchJson({ wrong: true }));
    await expect(openAICompatibleProvider({ ...opts, retries: 0 }).anonymize('x')).rejects.toThrow(
      'LLM_BAD_SHAPE',
    );
  });

  describe('retry/backoff', () => {
    const retryOpts = { ...opts, retries: 1, retryDelayMs: 0 };

    it('retries once on a transient 500 then succeeds (2 calls)', async () => {
      const fetchMock = vi
        .fn()
        .mockResolvedValueOnce({ ok: false, status: 500 })
        .mockResolvedValueOnce({
          ok: true,
          json: async () => ({
            choices: [{ message: { content: JSON.stringify({ texte_anonymise: 'ok', mapping: {} }) } }],
          }),
        });
      vi.stubGlobal('fetch', fetchMock);

      const r = await openAICompatibleProvider(retryOpts).anonymize('x');
      expect(r.anon).toBe('ok');
      expect(fetchMock).toHaveBeenCalledTimes(2);
    });

    it('retries on a network error then succeeds', async () => {
      const fetchMock = vi
        .fn()
        .mockRejectedValueOnce(new Error('ECONNRESET'))
        .mockResolvedValueOnce({
          ok: true,
          json: async () => ({
            choices: [{ message: { content: JSON.stringify({ texte_anonymise: 'ok', mapping: {} }) } }],
          }),
        });
      vi.stubGlobal('fetch', fetchMock);

      const r = await openAICompatibleProvider(retryOpts).anonymize('x');
      expect(r.anon).toBe('ok');
      expect(fetchMock).toHaveBeenCalledTimes(2);
    });

    it('does NOT retry a 400 (non-transient)', async () => {
      const fetchMock = vi.fn().mockResolvedValue({ ok: false, status: 400 });
      vi.stubGlobal('fetch', fetchMock);
      await expect(openAICompatibleProvider(retryOpts).anonymize('x')).rejects.toThrow('LLM_HTTP_400');
      expect(fetchMock).toHaveBeenCalledTimes(1);
    });

    it('gives up after exhausting retries on persistent 503', async () => {
      const fetchMock = vi.fn().mockResolvedValue({ ok: false, status: 503 });
      vi.stubGlobal('fetch', fetchMock);
      await expect(openAICompatibleProvider(retryOpts).anonymize('x')).rejects.toThrow('LLM_HTTP_503');
      expect(fetchMock).toHaveBeenCalledTimes(2); // initial + 1 retry
    });
  });
});