import {MockAgent, setGlobalDispatcher} from 'undici'
import {createStorageRecord} from '../src/artifactMetadata'

describe('createStorageRecord', () => {
  const originalEnv = process.env
  const attestation = {foo: 'bar '}
  const token = 'token'
  const headers = {'X-GitHub-Foo': 'true'}
  const artifactOptions = {
    name: "my-lib",
    version: "1.0.0",
    digest: "sha256:1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
  }
  const registryOptions = {
    registryUrl: 'https://my-registry.org',
  }

  const mockAgent = new MockAgent()
  setGlobalDispatcher(mockAgent)

  beforeEach(() => {
    process.env = {
      ...originalEnv,
      GITHUB_REPOSITORY: 'foo/bar'
    }
  })

  afterEach(() => {
    process.env = originalEnv
  })

  describe('when the api call is successful', () => {
    beforeEach(() => {
      mockAgent
        .get('https://api.github.com')
        .intercept({
          path: '/orgs/foo/artifacts/metadata/storage-record',
          method: 'POST',
          headers: {authorization: `token ${token}`, ...headers},
          body: JSON.stringify({
            name: "my-lib",
            version: "1.0.0",
            digest: "sha256:1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
            registry_url: "https://my-registry.org"
          })
        })
        .reply(201, {storage_records: [{id: '123'}, {id: '456'}]})
    })

    it('persists the storage record', async () => {
      await expect(
        createStorageRecord({
          artifactOptions: artifactOptions,
          packageRegistryOptions: registryOptions,
          token,
          writeOptions: {headers},
        })
      ).resolves.toEqual(['123', '456'])
    })
  })

  describe('when the api call fails', () => {
    beforeEach(() => {
      mockAgent
        .get('https://api.github.com')
        .intercept({
          path: '/orgs/foo/artifacts/metadata/storage-record',
          method: 'POST',
          headers: {authorization: `token ${token}`},
          body: JSON.stringify({
            name: "my-lib",
            version: "1.0.0",
            digest: "sha256:1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
            registry_url: "https://my-registry.org"
          })
        })
        .reply(500, 'oops')
    })

    it('throws an error', async () => {
      await expect(
        createStorageRecord({
          artifactOptions: artifactOptions,
          packageRegistryOptions: registryOptions,
          token,
          writeOptions: {retry: 0},
        })
      ).rejects.toThrow(/oops/)
    })
  })

  describe('when the api call fails but succeeds on retry', () => {
    beforeEach(() => {
      const pool = mockAgent.get('https://api.github.com')

      pool
        .intercept({
          path: '/repos/foo/bar/attestations',
          method: 'POST',
          headers: {authorization: `token ${token}`},
          body: JSON.stringify({...artifactOptions, registry_url: registryOptions.registryUrl})
        })
        .reply(500, 'oops')
        .times(1)

      pool
        .intercept({
          path: '/repos/foo/bar/attestations',
          method: 'POST',
          headers: {authorization: `token ${token}`},
          body: JSON.stringify({})
        })
        .reply(201, {storage_records: [{id: '123'}, {id: '456'}]})
        .times(1)
    })

    it('persists the attestation', async () => {
      const { registryUrl, ...rest } = registryOptions
      await expect(createStorageRecord({
        ...artifactOptions,
        ...rest,
        registry_url: registryUrl,
        token,
        writeOptions: {},
      })).resolves.toEqual(['123', '456'])
    })
  })
})