netanalyzer/tests/atlasClient.test.js

jest.mock('../config', () => ({ logLevel: 'error' }));

jest.mock('axios', () => {
  const get = jest.fn();
  const create = jest.fn(() => ({ get }));
  return { __esModule: true, default: { create }, create, __get: get };
});

const axios = require('axios');
const atlasClientModule = require('../integrations/atlas/atlasClient');
const { atlasGet, AtlasUnavailableError, resetClientForTests } = atlasClientModule;

describe('atlasClient', () => {
  const originalKey = process.env.ATLAS_AUTH_KEY;

  beforeEach(() => {
    jest.clearAllMocks();
    resetClientForTests();
  });

  afterAll(() => {
    if (originalKey === undefined) delete process.env.ATLAS_AUTH_KEY;
    else process.env.ATLAS_AUTH_KEY = originalKey;
  });

  it('throws AtlasUnavailableError when ATLAS_AUTH_KEY is missing', async () => {
    delete process.env.ATLAS_AUTH_KEY;
    await expect(atlasGet('organization/devices')).rejects.toBeInstanceOf(AtlasUnavailableError);
  });

  it('creates an axios instance with the env-provided Authorization header (no Bearer prefix)', async () => {
    process.env.ATLAS_AUTH_KEY = 'secret-token-123';
    axios.__get.mockResolvedValue({ status: 200, data: { ok: true } });

    await atlasGet('organization/devices', { page: 1 });

    expect(axios.create).toHaveBeenCalledTimes(1);
    const cfg = axios.create.mock.calls[0][0];
    expect(cfg.headers.Authorization).toBe('secret-token-123');
    expect(cfg.baseURL).toBe('https://hub.xyte.io/core/v1');
  });

  it('honors ATLAS_BASE_URL override', async () => {
    process.env.ATLAS_AUTH_KEY = 'k';
    process.env.ATLAS_BASE_URL = 'https://atlas.test/api/v2';
    axios.__get.mockResolvedValue({ status: 200, data: {} });

    await atlasGet('organization/devices');

    expect(axios.create.mock.calls[0][0].baseURL).toBe('https://atlas.test/api/v2');
    delete process.env.ATLAS_BASE_URL;
  });

  it('returns response.data on success and strips leading slash from path', async () => {
    process.env.ATLAS_AUTH_KEY = 'k';
    axios.__get.mockResolvedValue({ status: 200, data: { items: [1, 2] } });

    const data = await atlasGet('/organization/devices', { page: 2 });
    expect(data).toEqual({ items: [1, 2] });
    expect(axios.__get).toHaveBeenCalledWith(
      '/organization/devices',
      expect.objectContaining({ params: { page: 2 } })
    );
  });

  it('throws with status detail on 4xx response', async () => {
    process.env.ATLAS_AUTH_KEY = 'k';
    axios.__get.mockResolvedValue({
      status: 403,
      statusText: 'Forbidden',
      data: { message: 'invalid key' },
    });

    await expect(atlasGet('organization/devices')).rejects.toThrow(/invalid key/);
  });
});