@ronaldphilipsen/local-action 0.0.0-stage → 7.0.1

package/__tests__/stubs/artifact/internal/find/get-artifact.test.ts

@@ -0,0 +1,237 @@
+import { jest } from '@jest/globals'
+import * as core from '../../../../../__fixtures__/@actions/core.js'
+import * as github from '../../../../../__fixtures__/@actions/github.js'
+import * as octokit from '../../../../../__fixtures__/@octokit/rest.js'
+import { ResetCoreMetadata } from '../../../../../src/stubs/core/core.js'
+import { EnvMeta, ResetEnvMetadata } from '../../../../../src/stubs/env.js'
+
+jest.unstable_mockModule('@octokit/rest', async () => {
+  class Octokit {
+    constructor() {
+      return octokit
+    }
+  }
+
+  return {
+    Octokit
+  }
+})
+
+jest.unstable_mockModule('../../../../../src/stubs/core/core.js', () => core)
+jest.unstable_mockModule(
+  '../../../../../src/stubs/github/github.js',
+  () => github
+)
+
+const getArtifact =
+  await import('../../../../../src/stubs/artifact/internal/find/get-artifact.js')
+
+const { Octokit } = await import('@octokit/rest')
+const mocktokit = jest.mocked(new Octokit())
+
+describe('get-artifact', () => {
+  beforeEach(() => {
+    // Reset metadata
+    ResetEnvMetadata()
+    ResetCoreMetadata()
+  })
+
+  afterEach(() => {
+    jest.resetAllMocks()
+  })
+
+  describe('getArtifactPublic', () => {
+    it('Gets an artifact', async () => {
+      mocktokit.request.mockResolvedValue({
+        data: {
+          artifacts: [
+            {
+              name: 'artifact-name',
+              id: 1,
+              size_in_bytes: 0,
+              created_at: new Date().toISOString()
+            }
+          ]
+        },
+        status: 200,
+        headers: {
+          'x-github-request-id': 'request-id'
+        }
+      } as any)
+
+      const response = await getArtifact.getArtifactPublic(
+        'artifact-name',
+        1,
+        'owner',
+        'repo',
+        'token'
+      )
+
+      expect(mocktokit.request).toHaveBeenCalledTimes(1)
+      expect(response).toMatchObject({
+        artifact: {
+          name: 'artifact-name',
+          id: 1,
+          size: 0,
+          createdAt: expect.any(Date)
+        }
+      })
+    })
+
+    it('Throws if there is an API error', async () => {
+      mocktokit.request.mockResolvedValue({
+        status: 500,
+        headers: {
+          'x-github-request-id': 'request-id'
+        }
+      } as any)
+
+      await expect(
+        getArtifact.getArtifactPublic(
+          'artifact-name',
+          1,
+          'owner',
+          'repo',
+          'token'
+        )
+      ).rejects.toThrow('Invalid response from GitHub API: 500 (request-id)')
+    })
+
+    it('Throws if no artifacts are found', async () => {
+      mocktokit.request.mockResolvedValue({
+        data: {
+          artifacts: []
+        },
+        status: 200,
+        headers: {
+          'x-github-request-id': 'request-id'
+        }
+      } as any)
+
+      await expect(
+        getArtifact.getArtifactPublic(
+          'artifact-name',
+          1,
+          'owner',
+          'repo',
+          'token'
+        )
+      ).rejects.toThrow()
+    })
+
+    it('Chooses the latest artifact if multiple are found', async () => {
+      mocktokit.request.mockResolvedValue({
+        data: {
+          artifacts: [
+            {
+              name: 'artifact-name',
+              id: 1,
+              size_in_bytes: 0,
+              created_at: new Date().toISOString()
+            },
+            {
+              name: 'artifact-name',
+              id: 2,
+              size_in_bytes: 0,
+              created_at: new Date().toISOString()
+            }
+          ]
+        },
+        status: 200,
+        headers: {
+          'x-github-request-id': 'request-id'
+        }
+      } as any)
+
+      const response = await getArtifact.getArtifactPublic(
+        'artifact-name',
+        1,
+        'owner',
+        'repo',
+        'token'
+      )
+
+      expect(mocktokit.request).toHaveBeenCalledTimes(1)
+      expect(response).toMatchObject({
+        artifact: {
+          name: 'artifact-name',
+          id: 2,
+          size: 0,
+          createdAt: expect.any(Date)
+        }
+      })
+    })
+
+    it('Returns an undefined date if there is no created_at', async () => {
+      mocktokit.request.mockResolvedValue({
+        data: {
+          artifacts: [
+            {
+              name: 'artifact-name',
+              id: 1,
+              size_in_bytes: 0,
+              created_at: undefined
+            }
+          ]
+        },
+        status: 200,
+        headers: {
+          'x-github-request-id': 'request-id'
+        }
+      } as any)
+
+      const response = await getArtifact.getArtifactPublic(
+        'artifact-name',
+        1,
+        'owner',
+        'repo',
+        'token'
+      )
+
+      expect(mocktokit.request).toHaveBeenCalledTimes(1)
+      expect(response).toMatchObject({
+        artifact: {
+          name: 'artifact-name',
+          id: 1,
+          size: 0,
+          createdAt: undefined
+        }
+      })
+    })
+  })
+
+  describe('getArtifactInternal', () => {
+    it('Gets an artifact', async () => {
+      EnvMeta.artifacts = [{ name: 'artifact-name', id: 1, size: 0 }]
+
+      const response = await getArtifact.getArtifactInternal('artifact-name')
+
+      expect(response.artifact).toMatchObject({
+        name: 'artifact-name',
+        id: 1,
+        size: 0
+      })
+    })
+
+    it('Gets the latest artifact', async () => {
+      EnvMeta.artifacts = [
+        { name: 'artifact-name', id: 1, size: 0 },
+        { name: 'artifact-name', id: 2, size: 0 }
+      ]
+
+      const response = await getArtifact.getArtifactInternal('artifact-name')
+
+      expect(response.artifact).toMatchObject({
+        name: 'artifact-name',
+        id: 2,
+        size: 0
+      })
+    })
+
+    it('Throws if no matching artifact is found', async () => {
+      await expect(
+        getArtifact.getArtifactInternal('artifact-name')
+      ).rejects.toThrow()
+    })
+  })
+})

package/__tests__/stubs/artifact/internal/find/list-artifacts.test.ts

@@ -0,0 +1,218 @@
+import { jest } from '@jest/globals'
+import * as core from '../../../../../__fixtures__/@actions/core.js'
+import * as github from '../../../../../__fixtures__/@actions/github.js'
+import * as octokit from '../../../../../__fixtures__/@octokit/rest.js'
+import { ResetCoreMetadata } from '../../../../../src/stubs/core/core.js'
+import { EnvMeta, ResetEnvMetadata } from '../../../../../src/stubs/env.js'
+
+jest.unstable_mockModule('@octokit/rest', async () => {
+  class Octokit {
+    constructor() {
+      return octokit
+    }
+  }
+
+  return {
+    Octokit
+  }
+})
+
+jest.unstable_mockModule('../../../../../src/stubs/core/core.js', () => core)
+jest.unstable_mockModule(
+  '../../../../../src/stubs/github/github.js',
+  () => github
+)
+
+const listArtifacts =
+  await import('../../../../../src/stubs/artifact/internal/find/list-artifacts.js')
+
+const { Octokit } = await import('@octokit/rest')
+const mocktokit = jest.mocked(new Octokit())
+
+describe('list-artifacts', () => {
+  beforeEach(() => {
+    // Reset metadata
+    ResetEnvMetadata()
+    ResetCoreMetadata()
+  })
+
+  afterEach(() => {
+    jest.resetAllMocks()
+  })
+
+  describe('listArtifactsPublic', () => {
+    it('Lists the artifacts', async () => {
+      mocktokit.rest.actions.listWorkflowRunArtifacts.mockResolvedValue({
+        data: {
+          total_count: 1,
+          artifacts: [
+            {
+              name: 'artifact-name',
+              id: 1,
+              size_in_bytes: 0,
+              created_at: new Date().toISOString()
+            }
+          ]
+        }
+      } as any)
+
+      const response = await listArtifacts.listArtifactsPublic(
+        1,
+        'owner',
+        'repo',
+        'token'
+      )
+
+      expect(
+        mocktokit.rest.actions.listWorkflowRunArtifacts
+      ).toHaveBeenCalledTimes(1)
+      expect(response).toMatchObject({
+        artifacts: [
+          {
+            name: 'artifact-name',
+            id: 1,
+            size: 0,
+            createdAt: expect.any(Date)
+          }
+        ]
+      })
+    })
+
+    it('Sets the date to undefined if created_at is not present', async () => {
+      mocktokit.rest.actions.listWorkflowRunArtifacts.mockResolvedValue({
+        data: {
+          total_count: 1,
+          artifacts: [
+            {
+              name: 'artifact-name',
+              id: 1,
+              size_in_bytes: 0
+            }
+          ]
+        }
+      } as any)
+
+      const response = await listArtifacts.listArtifactsPublic(
+        1,
+        'owner',
+        'repo',
+        'token'
+      )
+
+      expect(
+        mocktokit.rest.actions.listWorkflowRunArtifacts
+      ).toHaveBeenCalledTimes(1)
+      expect(response).toMatchObject({
+        artifacts: [
+          {
+            name: 'artifact-name',
+            id: 1,
+            size: 0,
+            createdAt: undefined
+          }
+        ]
+      })
+    })
+
+    it('Returns the first 1000 artifacts', async () => {
+      mocktokit.rest.actions.listWorkflowRunArtifacts.mockResolvedValue({
+        data: {
+          total_count: 1001,
+          artifacts: [
+            {
+              name: 'artifact-name',
+              id: 1,
+              size_in_bytes: 0,
+              created_at: new Date().toISOString()
+            }
+          ]
+        }
+      } as any)
+
+      await listArtifacts.listArtifactsPublic(1, 'owner', 'repo', 'token')
+
+      expect(mocktokit.rest.actions.listWorkflowRunArtifacts).toHaveBeenCalled()
+      expect(core.warning).toHaveBeenCalledWith(
+        'Workflow run 1 has more than 1000 artifacts. Results will be incomplete as only the first 1000 artifacts will be returned'
+      )
+    })
+
+    it('Filters the latest artifacts', async () => {
+      mocktokit.rest.actions.listWorkflowRunArtifacts.mockResolvedValue({
+        data: {
+          total_count: 3,
+          artifacts: [
+            {
+              name: 'artifact-name',
+              id: 1,
+              size_in_bytes: 0,
+              created_at: new Date().toISOString()
+            },
+            {
+              name: 'artifact-name',
+              id: 2,
+              size_in_bytes: 0,
+              created_at: new Date().toISOString()
+            },
+            {
+              name: 'artifact-name-2',
+              id: 3,
+              size_in_bytes: 0,
+              created_at: new Date().toISOString()
+            }
+          ]
+        }
+      } as any)
+
+      const response = await listArtifacts.listArtifactsPublic(
+        1,
+        'owner',
+        'repo',
+        'token',
+        true
+      )
+
+      expect(
+        mocktokit.rest.actions.listWorkflowRunArtifacts
+      ).toHaveBeenCalledTimes(1)
+      expect(response).toMatchObject({
+        artifacts: [
+          {
+            name: 'artifact-name-2',
+            id: 3,
+            size: 0,
+            createdAt: expect.any(Date)
+          },
+          {
+            name: 'artifact-name',
+            id: 2,
+            size: 0,
+            createdAt: expect.any(Date)
+          }
+        ]
+      })
+    })
+  })
+
+  describe('listArtifactsInternal', () => {
+    it('Lists artifacts', async () => {
+      EnvMeta.artifacts = [{ name: 'artifact-name', id: 1, size: 0 }]
+
+      const response = await listArtifacts.listArtifactsInternal()
+
+      expect(response.artifacts.length).toBe(1)
+    })
+
+    it('Only returns the latest artifacts', async () => {
+      EnvMeta.artifacts = [
+        { name: 'artifact-name', id: 1, size: 0 },
+        { name: 'artifact-name', id: 2, size: 0 },
+        { name: 'artifact-name-2', id: 3, size: 0 }
+      ]
+
+      const response = await listArtifacts.listArtifactsInternal(true)
+
+      expect(response.artifacts.length).toBe(2)
+    })
+  })
+})

package/__tests__/stubs/artifact/internal/find/retry-options.test.ts

@@ -0,0 +1,54 @@
+import { jest } from '@jest/globals'
+import * as retry from '../../../../../src/stubs/artifact/internal/find/retry-options.js'
+
+describe('retry-options', () => {
+  afterEach(() => {
+    jest.resetAllMocks()
+  })
+
+  describe('getRetryOptions', () => {
+    it('Gets the retry options', async () => {
+      const [retryOptions, requestOptions] = retry.getRetryOptions(
+        {} as any,
+        5,
+        [400, 401, 403, 404, 422]
+      )
+
+      expect(retryOptions).toEqual({
+        enabled: true,
+        doNotRetry: [400, 401, 403, 404, 422]
+      })
+      expect(requestOptions).toEqual({
+        retries: 5
+      })
+    })
+
+    it('Disables retries', async () => {
+      const [retryOptions, requestOptions] = retry.getRetryOptions(
+        {} as any,
+        0,
+        [400, 401, 403, 404, 422]
+      )
+
+      expect(retryOptions).toEqual({
+        enabled: false
+      })
+      expect(requestOptions).toBeUndefined()
+    })
+
+    it('Uses default exempt status codes', async () => {
+      const [retryOptions, requestOptions] = retry.getRetryOptions(
+        {} as any,
+        5,
+        []
+      )
+
+      expect(retryOptions).toEqual({
+        enabled: true
+      })
+      expect(requestOptions).toEqual({
+        retries: 5
+      })
+    })
+  })
+})

package/__tests__/stubs/artifact/internal/shared/config.test.ts

@@ -0,0 +1,91 @@
+import { jest } from '@jest/globals'
+import * as config from '../../../../../src/stubs/artifact/internal/shared/config.js'
+import { ResetCoreMetadata } from '../../../../../src/stubs/core/core.js'
+import { ResetEnvMetadata } from '../../../../../src/stubs/env.js'
+
+describe('config', () => {
+  beforeEach(() => {
+    // Reset metadata
+    ResetEnvMetadata()
+    ResetCoreMetadata()
+  })
+
+  afterEach(() => {
+    jest.resetAllMocks()
+
+    delete process.env.GITHUB_WORKSPACE
+    delete process.env.GITHUB_SERVER_URL
+  })
+
+  describe('getUploadChunkSize', () => {
+    it('Gets the upload chunk size', () => {
+      expect(config.getUploadChunkSize()).toEqual(8 * 1024 * 1024) // 8 MB
+    })
+  })
+
+  describe('isGhes', () => {
+    it('Returns false if using GitHub.com', () => {
+      process.env.GITHUB_SERVER_URL = 'https://github.com'
+
+      expect(config.isGhes()).toBe(false)
+    })
+
+    it('Returns false if using GitHub.com (default value)', () => {
+      expect(config.isGhes()).toBe(false)
+    })
+
+    it('Returns false if using GHE.com', () => {
+      process.env.GITHUB_SERVER_URL = 'https://example.ghe.com'
+
+      expect(config.isGhes()).toBe(false)
+    })
+
+    it('Returns false if using localhost', () => {
+      process.env.GITHUB_SERVER_URL = 'https://example.localhost'
+
+      expect(config.isGhes()).toBe(false)
+    })
+
+    it('Returns true if using a custom domain', () => {
+      process.env.GITHUB_SERVER_URL = 'https://example.com'
+
+      expect(config.isGhes()).toBe(true)
+    })
+  })
+
+  describe('getGitHubWorkspaceDir', () => {
+    it('Gets the workspace directory (default)', () => {
+      expect(config.getGitHubWorkspaceDir()).toEqual(process.cwd())
+    })
+
+    it('Gets the workspace directory (env var)', () => {
+      process.env.GITHUB_WORKSPACE = '/tmp/workspace'
+      expect(config.getGitHubWorkspaceDir()).toEqual('/tmp/workspace')
+    })
+  })
+
+  describe('getMaxArtifactListCount', () => {
+    it('Gets the default max artifact list count', () => {
+      expect(config.getMaxArtifactListCount()).toEqual(1000)
+    })
+
+    it('Gets the max artifact list count (env var)', () => {
+      process.env.ACTIONS_ARTIFACT_MAX_ARTIFACT_COUNT = '500'
+      expect(config.getMaxArtifactListCount()).toEqual(500)
+    })
+
+    it('Throws if the env var is not a number', () => {
+      process.env.ACTIONS_ARTIFACT_MAX_ARTIFACT_COUNT = 'hello'
+      expect(() => config.getMaxArtifactListCount()).toThrow(
+        'Invalid value set for ACTIONS_ARTIFACT_MAX_ARTIFACT_COUNT env variable'
+      )
+    })
+
+    it('Throws if the env var is less than 1', () => {
+      process.env.ACTIONS_ARTIFACT_MAX_ARTIFACT_COUNT = '0'
+      expect(() => config.getMaxArtifactListCount()).toThrow(
+        'Invalid value set for ACTIONS_ARTIFACT_MAX_ARTIFACT_COUNT env variable'
+      )
+    })
+  })
+})

package/__tests__/stubs/artifact/internal/shared/errors.test.ts

@@ -0,0 +1,38 @@
+import { jest } from '@jest/globals'
+import * as errors from '../../../../../src/stubs/artifact/internal/shared/errors.js'
+
+describe('errors', () => {
+  afterEach(() => {
+    jest.resetAllMocks()
+  })
+
+  describe('FilesNotFoundError', () => {
+    it('Returns a default message', () => {
+      const error = new errors.FilesNotFoundError()
+
+      expect(error.message).toEqual('No files were found to upload')
+    })
+
+    it('Returns a list of files', () => {
+      const error = new errors.FilesNotFoundError(['file1', 'file2'])
+
+      expect(error.message).toEqual(
+        'No files were found to upload: file1, file2'
+      )
+    })
+  })
+
+  describe('ArtifactNotFoundError', () => {
+    it('Returns a default message', () => {
+      const error = new errors.ArtifactNotFoundError()
+
+      expect(error.message).toEqual('Artifact not found')
+    })
+
+    it('Returns a custom message', () => {
+      const error = new errors.ArtifactNotFoundError('Custom message')
+
+      expect(error.message).toEqual('Custom message')
+    })
+  })
+})

package/__tests__/stubs/artifact/internal/shared/user-agent.test.ts

@@ -0,0 +1,22 @@
+import { jest } from '@jest/globals'
+import { getUserAgentString } from '../../../../../src/stubs/artifact/internal/shared/user-agent.js'
+import { ResetCoreMetadata } from '../../../../../src/stubs/core/core.js'
+import { ResetEnvMetadata } from '../../../../../src/stubs/env.js'
+
+describe('user-agent', () => {
+  beforeEach(() => {
+    // Reset metadata
+    ResetEnvMetadata()
+    ResetCoreMetadata()
+  })
+
+  afterEach(() => {
+    jest.resetAllMocks()
+  })
+
+  it('Outputs the correct user agent header', () => {
+    expect(getUserAgentString()).toEqual(
+      `@ronaldphilipsen/local-action-${process.env.npm_package_version}`
+    )
+  })
+})