code-review/app/llm.test.js

import { describe, it, beforeEach, afterEach, mock } from 'node:test';
import assert from 'node:assert/strict';

// Mock axios before importing llm.js
import axios from 'axios';

const ENV_KEYS = [
  'OPENAI_API_KEY', 'OPENAI_BASE_URL', 'OPENAI_MODEL',
  'GEMINI_API_KEY', 'GEMINI_BASE_URL', 'GEMINI_MODEL',
  'CLAUDE_API_KEY', 'CLAUDE_BASE_URL', 'CLAUDE_MODEL',
  'OLLAMA_BASE_URL', 'OLLAMA_MODEL',
  'AMAZONQ_API_KEY', 'AMAZONQ_BASE_URL', 'AMAZONQ_MODEL',
  'OPENCODE_BASE_URL', 'OPENCODE_MODEL', 'OPENCODE_PROVIDER',
  'OPENCODE_SERVER_USERNAME', 'OPENCODE_SERVER_PASSWORD',
];

let saved = {};
beforeEach(() => {
  saved = {};
  for (const k of ENV_KEYS) { saved[k] = process.env[k]; delete process.env[k]; }
});
afterEach(() => {
  for (const k of ENV_KEYS) {
    if (saved[k] === undefined) delete process.env[k];
    else process.env[k] = saved[k];
  }
  mock.restoreAll();
});

function mockAxiosPost(responses) {
  let call = 0;
  mock.method(axios, 'post', async () => {
    const r = responses[call++] ?? responses[responses.length - 1];
    if (r instanceof Error) throw r;
    return r;
  });
}

function makeOkResponse(content = 'ok') {
  return { data: { choices: [{ message: { content } }] } };
}

describe('chat - key rotation', async () => {
  const { chat } = await import('./llm.js');

  it('succeeds on first key', async () => {
    process.env.OPENAI_API_KEY = 'key1';
    mockAxiosPost([makeOkResponse('hello')]);
    const result = await chat('sys', 'user');
    assert.equal(result, 'hello');
  });

  it('shuffles keys and tries each exactly once', async () => {
    process.env.OPENAI_API_KEY = 'key1,key2,key3';
    const usedKeys = [];
    mock.method(axios, 'post', async (_url, _body, opts) => {
      usedKeys.push(opts.headers['Authorization'].replace('Bearer ', ''));
      throw new Error('fail');
    });
    const exitMock = mock.method(process, 'exit', () => { throw new Error('exit:1'); });
    await assert.rejects(() => chat('sys', 'user'), /exit:1/);
    assert.equal(exitMock.mock.calls[0].arguments[0], 1);
    assert.equal(usedKeys.length, 3);
    assert.deepEqual([...usedKeys].sort(), ['key1', 'key2', 'key3']);
  });

  it('calls process.exit(1) when all keys fail', async () => {
    process.env.OPENAI_API_KEY = 'k1,k2';
    mockAxiosPost([new Error('fail'), new Error('fail')]);
    const exitMock = mock.method(process, 'exit', () => { throw new Error('exit:1'); });
    await assert.rejects(() => chat('sys', 'user'), /exit:1/);
    assert.equal(exitMock.mock.calls[0].arguments[0], 1);
  });

  it('does not set Authorization header for ollama', async () => {
    process.env.OLLAMA_BASE_URL = 'http://localhost:11434/v1';
    process.env.OLLAMA_MODEL = 'llama3';
    let capturedHeaders;
    mock.method(axios, 'post', async (_url, _body, opts) => {
      capturedHeaders = opts.headers;
      return makeOkResponse('ollama response');
    });
    await chat('sys', 'user');
    assert.equal(capturedHeaders['Authorization'], undefined);
  });

  it('sets Authorization header for openai', async () => {
    process.env.OPENAI_API_KEY = 'sk-test';
    let capturedHeaders;
    mock.method(axios, 'post', async (_url, _body, opts) => {
      capturedHeaders = opts.headers;
      return makeOkResponse();
    });
    await chat('sys', 'user');
    assert.equal(capturedHeaders['Authorization'], 'Bearer sk-test');
  });

  it('does not set timeout', async () => {
    process.env.OPENAI_API_KEY = 'sk-test';
    let capturedOpts;
    mock.method(axios, 'post', async (_url, _body, opts) => {
      capturedOpts = opts;
      return makeOkResponse();
    });
    await chat('sys', 'user');
    assert.equal(capturedOpts.timeout, undefined);
  });

  it('does not pass httpsAgent to axios', async () => {
    process.env.OPENAI_API_KEY = 'sk-test';
    let capturedOpts;
    mock.method(axios, 'post', async (_url, _body, opts) => {
      capturedOpts = opts;
      return makeOkResponse();
    });
    await chat('sys', 'user');
    assert.equal(capturedOpts.httpsAgent, undefined);
  });

  it('sets anthropic-version header for claude', async () => {
    process.env.CLAUDE_API_KEY = 'claude-key';
    let capturedHeaders;
    mock.method(axios, 'post', async (_url, _body, opts) => {
      capturedHeaders = opts.headers;
      return makeOkResponse();
    });
    await chat('sys', 'user');
    assert.equal(capturedHeaders['anthropic-version'], '2023-06-01');
  });

  it('uses OpenCode server session API for opencode', async () => {
    process.env.OPENCODE_BASE_URL = 'http://opencode.local:4096';
    process.env.OPENCODE_PROVIDER = 'google';
    process.env.OPENCODE_MODEL = 'gemini-2.5-flash';
    const calls = [];
    mock.method(axios, 'post', async (url, payload, opts) => {
      calls.push({ url, payload, headers: opts.headers });
      if (url.endsWith('/session')) return { data: { id: 'ses_test' } };
      return { data: { parts: [{ type: 'text', text: 'opencode response' }] } };
    });
    const result = await chat('sys', 'user');
    assert.equal(result, 'opencode response');
    assert.equal(calls[0].url, 'http://opencode.local:4096/session');
    assert.deepEqual(calls[0].payload.model, { providerID: 'google', id: 'gemini-2.5-flash' });
    assert.equal(calls[1].url, 'http://opencode.local:4096/session/ses_test/message');
    assert.deepEqual(calls[1].payload.model, { providerID: 'google', modelID: 'gemini-2.5-flash' });
    assert.equal(calls[1].payload.system, 'sys');
    assert.deepEqual(calls[1].payload.parts, [{ type: 'text', text: 'user' }]);
    assert.equal(calls[1].headers['Authorization'], undefined);
  });

  it('uses Basic Auth for protected OpenCode server', async () => {
    process.env.OPENCODE_BASE_URL = 'http://opencode.local:4096';
    process.env.OPENCODE_SERVER_USERNAME = 'opencode';
    process.env.OPENCODE_SERVER_PASSWORD = 'secret';
    const headers = [];
    mock.method(axios, 'post', async (url, _payload, opts) => {
      headers.push(opts.headers);
      if (url.endsWith('/session')) return { data: { id: 'ses_test' } };
      return { data: { parts: [{ type: 'text', text: 'ok' }] } };
    });
    await chat('sys', 'user');
    assert.equal(headers[0]['Authorization'], `Basic ${Buffer.from('opencode:secret').toString('base64')}`);
  });

  it('uses Responses API for openai GPT-5.5', async () => {
    process.env.OPENAI_API_KEY = 'sk-test';
    process.env.OPENAI_MODEL = 'GPT-5.5';
    let capturedUrl, capturedPayload;
    mock.method(axios, 'post', async (url, payload) => {
      capturedUrl = url;
      capturedPayload = payload;
      return { data: { output_text: 'gpt response' } };
    });
    const result = await chat('sys', 'user');
    assert.equal(result, 'gpt response');
    assert.equal(capturedUrl, 'https://api.openai.com/v1/responses');
    assert.deepEqual(capturedPayload, { model: 'GPT-5.5', instructions: 'sys', input: 'user', temperature: 0.2 });
  });

  it('extracts opencode text from message parts', async () => {
    process.env.OPENCODE_BASE_URL = 'http://opencode.local:4096';
    let calls = 0;
    mock.method(axios, 'post', async () => {
      calls += 1;
      if (calls === 1) return { data: { id: 'ses_test' } };
      return { data: { parts: [{ type: 'text', text: 'hello' }, { type: 'text', text: ' world' }] } };
    });
    const result = await chat('sys', 'user');
    assert.equal(result, 'hello world');
  });
});

describe('chatJSON', async () => {
  const { chatJSON } = await import('./llm.js');

  it('parses plain JSON response', async () => {
    process.env.OPENAI_API_KEY = 'sk-test';
    mockAxiosPost([makeOkResponse('[{"level":"critical"}]')]);
    const result = await chatJSON('sys', 'user');
    assert.deepEqual(result, [{ level: 'critical' }]);
  });

  it('strips markdown code block before parsing', async () => {
    process.env.OPENAI_API_KEY = 'sk-test';
    mockAxiosPost([makeOkResponse('```json\n[{"level":"info"}]\n```')]);
    const result = await chatJSON('sys', 'user');
    assert.deepEqual(result, [{ level: 'info' }]);
  });

  it('returns [] when JSON is invalid', async () => {
    process.env.OPENAI_API_KEY = 'sk-test';
    mockAxiosPost([makeOkResponse('not json')]);
    const result = await chatJSON('sys', 'user');
    assert.deepEqual(result, []);
  });
});