ApiCore/ApiCore-Backend/src/voice/anthropic-config.spec.ts

import { Logger } from '@nestjs/common';
import { anthropicApiKey, assertAnthropicKey } from './anthropic-config';

const KEY = 'sk-ant-api03-abcdefghijklmnopqrstuvwxyz0123456789';

function fakeLogger() {
  return { warn: jest.fn(), error: jest.fn() } satisfies Pick<
    Logger,
    'warn' | 'error'
  >;
}

describe('anthropicApiKey', () => {
  it('returns a well-formed key, trimmed', () => {
    expect(anthropicApiKey({ ANTHROPIC_API_KEY: ` ${KEY} ` })).toBe(KEY);
  });

  it.each([
    ['unset', {}],
    ['empty', { ANTHROPIC_API_KEY: '  ' }],
    ['a placeholder', { ANTHROPIC_API_KEY: 'change-me-anthropic-key' }],
    ['the wrong format', { ANTHROPIC_API_KEY: 'sk-ant-short' }],
    ['dummy', { ANTHROPIC_API_KEY: 'dummy' }],
  ])('returns null for %s', (_label, env) => {
    expect(anthropicApiKey(env)).toBeNull();
  });
});

describe('assertAnthropicKey', () => {
  it('assertAnthropicKey never throws and disables on a placeholder', () => {
    for (const value of ['change-me-anthropic-key', 'dummy', '', 'sk-ant-x']) {
      const logger = fakeLogger();
      expect(() =>
        assertAnthropicKey(
          'worker',
          { NODE_ENV: 'production', ANTHROPIC_API_KEY: value },
          logger,
        ),
      ).not.toThrow();
    }
    const logger = fakeLogger();
    assertAnthropicKey(
      'worker',
      { NODE_ENV: 'production', ANTHROPIC_API_KEY: 'change-me-x' },
      logger,
    );
    expect(logger.error).toHaveBeenCalledTimes(1);
    expect(anthropicApiKey({ ANTHROPIC_API_KEY: 'change-me-x' })).toBeNull();
  });

  it('logs the variable name once, never the value', () => {
    const logger = fakeLogger();
    assertAnthropicKey(
      'worker',
      { ANTHROPIC_API_KEY: 'sk-ant-short-secret' },
      logger,
    );
    const output = JSON.stringify([
      logger.warn.mock.calls,
      logger.error.mock.calls,
    ]);
    expect(output).toContain('ANTHROPIC_API_KEY');
    expect(output).not.toContain('short-secret');
    expect(logger.error).toHaveBeenCalledTimes(1);
  });

  it('api and job roles do not check the key format and stay silent without a key', () => {
    for (const role of ['api', 'job'] as const) {
      const logger = fakeLogger();
      assertAnthropicKey(role, {}, logger);
      assertAnthropicKey(role, { ANTHROPIC_API_KEY: '   ' }, logger);
      expect(logger.error).not.toHaveBeenCalled();
      expect(logger.warn).not.toHaveBeenCalled();
    }
  });

  it('warns once, by name, when an api or job role holds the key', () => {
    for (const role of ['api', 'job'] as const) {
      const logger = fakeLogger();
      assertAnthropicKey(role, { ANTHROPIC_API_KEY: KEY }, logger);
      expect(logger.warn).toHaveBeenCalledTimes(1);
      expect(logger.error).not.toHaveBeenCalled();
      const text = String((logger.warn.mock.calls[0] as unknown[])[0]);
      expect(text).toContain(`ANTHROPIC_API_KEY is set for role ${role}`);
      expect(text).toContain('apicore-anthropic');
      expect(text).not.toContain(KEY);
    }
  });

  it('accepts a good key silently in the worker and in all-in-one mode', () => {
    for (const role of ['worker', 'all'] as const) {
      const logger = fakeLogger();
      assertAnthropicKey(role, { ANTHROPIC_API_KEY: KEY }, logger);
      expect(logger.error).not.toHaveBeenCalled();
      expect(logger.warn).not.toHaveBeenCalled();
    }
  });

  it('warns that extraction stays off when the worker has no key', () => {
    const logger = fakeLogger();
    assertAnthropicKey('worker', {}, logger);
    expect(logger.warn).toHaveBeenCalledTimes(1);
    expect(logger.error).not.toHaveBeenCalled();
  });
});