auth-helper.test.js

const { getAccessToken, bearerAuthHandler, setRuntimeApiHostAndAuthHandler, getTokenData } = require('../../../src/lib/auth-helper')
const { getToken, context } = require('@adobe/aio-lib-ims')
const { CLI } = require('@adobe/aio-lib-ims/src/context')
const { getCliEnv } = require('@adobe/aio-lib-env')

jest.mock('@adobe/aio-lib-ims')
jest.mock('@adobe/aio-lib-env')

describe('getAccessToken', () => {
  beforeEach(() => {
    jest.clearAllMocks()
  })

  test('should get token using CLI context (default) if current context undefined', async () => {
    const mockToken = 'mocked-token'
    const mockEnv = 'prod'
    getToken.mockResolvedValue(mockToken)
    getCliEnv.mockReturnValue(mockEnv)
    context.getCurrent.mockResolvedValue(undefined)

    const result = await getAccessToken()

    expect(context.setCli).toHaveBeenCalledWith({ 'cli.bare-output': true }, false)
    expect(getCliEnv).toHaveBeenCalled()
    expect(getToken).toHaveBeenCalledWith(CLI)
    expect(result).toEqual({ accessToken: mockToken, env: mockEnv })
  })

  test('should use custom context if set', async () => {
    const mockToken = 'mocked-token'
    const mockEnv = 'prod'
    const customContext = 'custom-context'
    getToken.mockResolvedValue(mockToken)
    getCliEnv.mockReturnValue(mockEnv)
    context.getCurrent.mockResolvedValue(customContext)

    const result = await getAccessToken()

    expect(context.setCli).not.toHaveBeenCalled()
    expect(getToken).toHaveBeenCalledWith(customContext)
    expect(result).toEqual({ accessToken: mockToken, env: mockEnv })
  })

  test('should use cached token when requested', async () => {
    const mockToken = 'cached-token'
    const mockEnv = 'prod'
    const mockContext = { data: { access_token: { token: mockToken } } }
    getCliEnv.mockReturnValue(mockEnv)
    context.getCurrent.mockResolvedValue(CLI)
    context.get.mockResolvedValue(mockContext)

    const result = await getAccessToken({ useCachedToken: true })

    expect(getToken).not.toHaveBeenCalled()
    expect(context.get).toHaveBeenCalledWith(CLI)
    expect(result).toEqual({ accessToken: mockToken, env: mockEnv })
  })
})

describe('getTokenData', () => {
  test('should decode JWT token and return payload', () => {
    // Example JWT token with payload: {"user_id":"12345","name":"Test User"}
    const exampleToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX2lkIjoiMTIzNDUiLCJuYW1lIjoiVGVzdCBVc2VyIn0.sflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c'
    const result = getTokenData(exampleToken)
    expect(result).toEqual({ user_id: '12345', name: 'Test User' })
  })
  test('should return null for invalid token', () => {
    const invalidToken = 'invalid.token.string'
    const result = getTokenData(invalidToken)
    expect(result).toBeNull()
  })
  test('should return null for malformed token', () => {
    const malformedToken = 'malformedtoken'
    const result = getTokenData(malformedToken)
    expect(result).toBeNull()
  })
  test('should return null for non-string token', () => {
    const nonStringToken = 12345
    const result = getTokenData(nonStringToken)
    expect(result).toBeNull()
  })
})

describe('bearerAuthHandler', () => {
  beforeEach(() => {
    jest.clearAllMocks()
  })

  test('getAuthHeader should return a Bearer token', async () => {
    const mockToken = 'mocked-token'
    getToken.mockResolvedValue(mockToken)
    getCliEnv.mockReturnValue('prod')
    context.getCurrent.mockResolvedValue(CLI)

    const result = await bearerAuthHandler.getAuthHeader()

    expect(result).toBe(`Bearer ${mockToken}`)
  })
})

describe('setRuntimeApiHostAndAuthHandler', () => {
  const DEPLOY_SERVICE_ENDPOINTS = {
    prod: 'https://deploy-service.app-builder.adp.adobe.io',
    stage: 'https://deploy-service.stg.app-builder.adp.adobe.io'
  }

  beforeEach(() => {
    jest.clearAllMocks()
    delete process.env.AIO_DEPLOY_SERVICE_URL
  })

  test('should set runtime.apihost and runtime.auth_handler when config has runtime', () => {
    // test both envs
    {
      const mockEnv = 'prod'
      getCliEnv.mockReturnValue(mockEnv)

      const config = { runtime: {} }
      const result = setRuntimeApiHostAndAuthHandler(config)

      expect(result.runtime.apihost).toBe(`${DEPLOY_SERVICE_ENDPOINTS[mockEnv]}/runtime`)
      expect(result.runtime.auth_handler).toBe(bearerAuthHandler)
    }
    {
      const mockEnv = 'stage'
      getCliEnv.mockReturnValue(mockEnv)

      const config = { runtime: {} }
      const result = setRuntimeApiHostAndAuthHandler(config)

      expect(result.runtime.apihost).toBe(`${DEPLOY_SERVICE_ENDPOINTS[mockEnv]}/runtime`)
      expect(result.runtime.auth_handler).toBe(bearerAuthHandler)
    }
  })

  test('should set ow.apihost and ow.auth_handler when config has ow', () => {
    const mockEnv = 'unknown-env-should-use-prod'
    getCliEnv.mockReturnValue(mockEnv)

    const config = { ow: {} }
    const result = setRuntimeApiHostAndAuthHandler(config)

    expect(result.ow.apihost).toBe(`${DEPLOY_SERVICE_ENDPOINTS.prod}/runtime`)
    expect(result.ow.auth_handler).toBe(bearerAuthHandler)
  })

  test('should use custom deploy service URL from environment', () => {
    const mockEnv = 'prod'
    getCliEnv.mockReturnValue(mockEnv)

    const customUrl = 'https://custom-deploy-service.example.com'
    process.env.AIO_DEPLOY_SERVICE_URL = customUrl
    const config = { runtime: {} }
    const result = setRuntimeApiHostAndAuthHandler(config)

    expect(result.runtime.apihost).toBe(`${customUrl}/runtime`)
  })

  test('should return undefined when config is null or undefined', () => {
    expect(setRuntimeApiHostAndAuthHandler(null)).not.toBeDefined()
    expect(setRuntimeApiHostAndAuthHandler()).not.toBeDefined()
  })

  test('should return undefined when config has neither runtime nor ow', () => {
    const config = { other: {} }
    const result = setRuntimeApiHostAndAuthHandler(config)
    expect(result).not.toBeDefined()
  })
})