Add basic tests

Author: aledbf

.github/workflows/check-dist.yml renamed to .github/workflows/ci.yml

@@ -1,4 +1,4 @@
-name: Check dist/
+name: CI
 
 on:
   push:
@@ -7,6 +7,22 @@ on:
   pull_request:
 
 jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run tests
+        run: npm test
+
   check-dist:
     runs-on: ubuntu-latest
     steps:

package.json

@@ -6,7 +6,7 @@
   "type": "module",
   "scripts": {
     "build": "ncc build index.mjs -o dist",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "node --test test.mjs"
   },
   "keywords": [
     "github",

test.mjs

@@ -0,0 +1,139 @@
+import { test } from 'node:test'
+import assert from 'node:assert'
+
+// Mock @actions/core
+const mockCore = {
+    getInput: (name, options) => {
+        const inputs = {
+            'app-id': '123456',
+            'private-key': '-----BEGIN RSA PRIVATE KEY-----\ntest\n-----END RSA PRIVATE KEY-----',
+            'installation-id': '12345678'
+        }
+        const value = inputs[name]
+        if (options?.required && !value) {
+            throw new Error(`Input required and not supplied: ${name}`)
+        }
+        return value || ''
+    },
+    setOutput: (name, value) => {
+        mockCore.outputs[name] = value
+    },
+    setSecret: (secret) => {
+        mockCore.secrets.push(secret)
+    },
+    setFailed: (error) => {
+        mockCore.failed = error
+    },
+    outputs: {},
+    secrets: [],
+    failed: null
+}
+
+// Mock @octokit/core
+class MockOctokit {
+    constructor(options) {
+        this.authStrategy = options.authStrategy
+        this.auth = options.auth
+    }
+
+    async auth(options) {
+        // Simulate successful authentication
+        return { token: 'ghs_mockToken123456789' }
+    }
+}
+
+// Mock @octokit/auth-app
+const createAppAuth = (options) => {
+    return async (authOptions) => {
+        return { token: 'ghs_mockToken123456789' }
+    }
+}
+
+test('generates token successfully with valid inputs', async (t) => {
+    // Reset mocks
+    mockCore.outputs = {}
+    mockCore.secrets = []
+    mockCore.failed = null
+
+    // Mock the modules
+    const originalCore = await import('@actions/core')
+    const coreModule = { ...originalCore, ...mockCore }
+
+    // Simulate the action logic
+    const appId = mockCore.getInput('app-id', { required: true })
+    const privateKey = mockCore.getInput('private-key', { required: true })
+    const installationId = mockCore.getInput('installation-id', { required: true })
+
+    assert.strictEqual(appId, '123456')
+    assert.strictEqual(installationId, '12345678')
+    assert.ok(privateKey.includes('BEGIN RSA PRIVATE KEY'))
+
+    // Simulate auth
+    const token = 'ghs_mockToken123456789'
+    mockCore.setOutput('token', token)
+    mockCore.setSecret(token)
+
+    assert.strictEqual(mockCore.outputs.token, 'ghs_mockToken123456789')
+    assert.strictEqual(mockCore.secrets[0], 'ghs_mockToken123456789')
+    assert.strictEqual(mockCore.failed, null)
+})
+
+test('fails when required input is missing', async (t) => {
+    const mockCoreNoInput = {
+        getInput: (name, options) => {
+            if (options?.required) {
+                throw new Error(`Input required and not supplied: ${name}`)
+            }
+            return ''
+        },
+        setFailed: (error) => {
+            mockCoreNoInput.failed = error
+        },
+        failed: null
+    }
+
+    try {
+        mockCoreNoInput.getInput('app-id', { required: true })
+        assert.fail('Should have thrown an error')
+    } catch (error) {
+        assert.ok(error.message.includes('Input required and not supplied'))
+    }
+})
+
+test('masks token in output', async (t) => {
+    mockCore.secrets = []
+    const token = 'ghs_secretToken123'
+    mockCore.setSecret(token)
+
+    assert.ok(mockCore.secrets.includes(token))
+    assert.strictEqual(mockCore.secrets.length, 1)
+})
+
+test('handles authentication errors gracefully', async (t) => {
+    mockCore.failed = null
+
+    const error = new Error('Bad credentials')
+    error.stack = 'Error: Bad credentials\n  at auth.js:10:15'
+
+    mockCore.setFailed(error)
+
+    assert.ok(mockCore.failed)
+    assert.ok(mockCore.failed.message === 'Bad credentials' || mockCore.failed === error)
+})
+
+test('validates private key format', async (t) => {
+    const privateKey = mockCore.getInput('private-key', { required: true })
+
+    // Check that private key has proper format markers
+    assert.ok(privateKey.includes('BEGIN RSA PRIVATE KEY'), 'Private key should have BEGIN marker')
+    assert.ok(privateKey.includes('END RSA PRIVATE KEY'), 'Private key should have END marker')
+})
+
+test('all required inputs are provided', async (t) => {
+    const requiredInputs = ['app-id', 'private-key', 'installation-id']
+
+    for (const input of requiredInputs) {
+        const value = mockCore.getInput(input, { required: true })
+        assert.ok(value, `Required input ${input} should have a value`)
+    }
+})