Fix retry bug. Add test suite (#19)

* Fix retry bug. Add test suite

* trigger CI

Author: Resonance1584

.github/workflows/tests.yml

@@ -0,0 +1,24 @@
+name: Tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
+        with:
+          node-version: 20
+          cache: npm
+          cache-dependency-path: test/package-lock.json
+      - run: npm ci
+        working-directory: test
+      - run: npm test
+        working-directory: test

action.yml

@@ -26,6 +26,7 @@ runs:
           const sleep = (ms) => new Promise(r => setTimeout(r, ms))
 
           const isRetryableError = (error) => {
+            const msg = String(error)
             // Network / transient errors
             if (/TypeError|ECONN|EPIPE|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|ECONNABORTED|socket disconnected|Request timeout|AbortError|TimeoutError|TLS/.test(msg)) return true
             // HTTP 5xx or 429 (rate limit)

test/.gitignore

@@ -0,0 +1 @@
+node_modules

test/action.test.js

@@ -0,0 +1,169 @@
+const { runAction } = require('./helpers/create-sandbox');
+
+function createCoreMock() {
+  return {
+    getIDToken: jest.fn().mockResolvedValue('mock-id-token'),
+    setOutput: jest.fn(),
+    setFailed: jest.fn(),
+  };
+}
+
+function okResponse(token) {
+  return { ok: true, status: 200, statusText: 'OK', body: { token } };
+}
+
+function errorResponse(status, statusText) {
+  return { ok: false, status, statusText };
+}
+
+function createFetchMock(responses) {
+  let callIndex = 0;
+  return jest.fn(async () => {
+    if (callIndex >= responses.length) {
+      throw new Error(`Unexpected fetch call #${callIndex + 1}`);
+    }
+    const resp = responses[callIndex++];
+    if (resp instanceof Error) throw resp;
+    return {
+      ok: resp.ok,
+      status: resp.status,
+      statusText: resp.statusText,
+      json: async () => resp.body,
+    };
+  });
+}
+
+const DEFAULT_ENV = {
+  API_BASE_URL: 'https://api.example.com/api/v1',
+  PIPELINES_TOKEN_PATH: 'org/repo',
+  FALLBACK_TOKEN: 'fallback-pat',
+};
+
+const LOGIN_URL = 'https://api.example.com/api/v1/tokens/auth/login';
+const TOKEN_URL = 'https://api.example.com/api/v1/tokens/pat/org/repo';
+
+describe('pipelines-credentials action', () => {
+  describe('happy path', () => {
+    test('OIDC login and token fetch', async () => {
+      const core = createCoreMock();
+      const fetch = createFetchMock([
+        okResponse('provider-token'),
+        okResponse('pipelines-pat'),
+      ]);
+
+      await runAction({ coreMock: core, fetchMock: fetch, env: DEFAULT_ENV });
+
+      expect(fetch).toHaveBeenCalledTimes(2);
+      expect(fetch.mock.calls[0][0]).toBe(LOGIN_URL);
+      expect(fetch.mock.calls[1][0]).toBe(TOKEN_URL);
+      expect(core.setOutput).toHaveBeenCalledWith('PIPELINES_TOKEN', 'pipelines-pat');
+      expect(core.setFailed).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('fallback behavior', () => {
+    test('uses FALLBACK_TOKEN when OIDC fails', async () => {
+      const core = createCoreMock();
+      core.getIDToken.mockRejectedValue(new Error('OIDC unavailable'));
+
+      await runAction({ coreMock: core, fetchMock: createFetchMock([]), env: DEFAULT_ENV });
+
+      expect(core.setOutput).toHaveBeenCalledWith('PIPELINES_TOKEN', 'fallback-pat');
+      expect(core.setFailed).not.toHaveBeenCalled();
+    });
+
+    test('trims whitespace from FALLBACK_TOKEN', async () => {
+      const core = createCoreMock();
+      core.getIDToken.mockRejectedValue(new Error('OIDC unavailable'));
+
+      await runAction({
+        coreMock: core,
+        fetchMock: createFetchMock([]),
+        env: { ...DEFAULT_ENV, FALLBACK_TOKEN: '  padded-token  ' },
+      });
+
+      expect(core.setOutput).toHaveBeenCalledWith('PIPELINES_TOKEN', 'padded-token');
+    });
+
+    test('calls setFailed when API fails and no FALLBACK_TOKEN', async () => {
+      const core = createCoreMock();
+      core.getIDToken.mockRejectedValue(new Error('OIDC unavailable'));
+
+      await runAction({
+        coreMock: core,
+        fetchMock: createFetchMock([]),
+        env: { ...DEFAULT_ENV, FALLBACK_TOKEN: '' },
+      });
+
+      expect(core.setFailed).toHaveBeenCalled();
+    });
+
+    test('uses FALLBACK_TOKEN when login returns non-retryable error', async () => {
+      const core = createCoreMock();
+      const fetch = createFetchMock([
+        errorResponse(403, 'Forbidden'),
+      ]);
+
+      await runAction({ coreMock: core, fetchMock: fetch, env: DEFAULT_ENV });
+
+      expect(core.setOutput).toHaveBeenCalledWith('PIPELINES_TOKEN', 'fallback-pat');
+      expect(fetch).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('retry behavior', () => {
+    test.each([
+      {
+        name: 'HTTP 500',
+        failResponse: errorResponse(500, 'Internal Server Error'),
+      },
+      {
+        name: 'HTTP 502',
+        failResponse: errorResponse(502, 'Bad Gateway'),
+      },
+      {
+        name: 'HTTP 429 rate limit',
+        failResponse: errorResponse(429, 'Too Many Requests'),
+      },
+      {
+        name: 'ECONNREFUSED network error',
+        failResponse: new Error('ECONNREFUSED'),
+      },
+      {
+        name: 'ETIMEDOUT network error',
+        failResponse: new Error('ETIMEDOUT'),
+      },
+      {
+        name: 'TypeError fetch failed',
+        failResponse: new TypeError('fetch failed'),
+      },
+    ])('retries on $name then succeeds', async ({ failResponse }) => {
+      const core = createCoreMock();
+      const fetch = createFetchMock([
+        failResponse,
+        okResponse('provider-token'),
+        okResponse('pipelines-pat'),
+      ]);
+
+      await runAction({ coreMock: core, fetchMock: fetch, env: DEFAULT_ENV });
+
+      expect(core.setOutput).toHaveBeenCalledWith('PIPELINES_TOKEN', 'pipelines-pat');
+      expect(fetch).toHaveBeenCalledTimes(3);
+    });
+
+    test('retries multiple times before succeeding', async () => {
+      const core = createCoreMock();
+      const fetch = createFetchMock([
+        errorResponse(500, 'Internal Server Error'),
+        errorResponse(500, 'Internal Server Error'),
+        okResponse('provider-token'),
+        okResponse('pipelines-pat'),
+      ]);
+
+      await runAction({ coreMock: core, fetchMock: fetch, env: DEFAULT_ENV });
+
+      expect(core.setOutput).toHaveBeenCalledWith('PIPELINES_TOKEN', 'pipelines-pat');
+      expect(fetch).toHaveBeenCalledTimes(4);
+    });
+  });
+});

test/helpers/create-sandbox.js

@@ -0,0 +1,28 @@
+const { extractScript } = require('./extract-script');
+
+const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;
+let cachedFn = null;
+
+function getSandboxedFn() {
+  if (!cachedFn) {
+    const script = extractScript();
+    cachedFn = new AsyncFunction(
+      'core', 'fetch', 'process', 'console', 'setTimeout', 'Math',
+      script
+    );
+  }
+  return cachedFn;
+}
+
+async function runAction({ coreMock, fetchMock, env = {} }) {
+  const fn = getSandboxedFn();
+
+  const processShim = { env: { ...env } };
+  const consoleShim = { log: jest.fn() };
+  const setTimeoutShim = (fn) => fn();
+  const mathShim = { ...Math, random: () => 0.5, pow: Math.pow, round: Math.round };
+
+  await fn(coreMock, fetchMock, processShim, consoleShim, setTimeoutShim, mathShim);
+}
+
+module.exports = { runAction };

test/helpers/extract-script.js

@@ -0,0 +1,12 @@
+const fs = require('fs');
+const path = require('path');
+const yaml = require('js-yaml');
+
+function extractScript() {
+  const actionPath = path.resolve(__dirname, '..', '..', 'action.yml');
+  const content = fs.readFileSync(actionPath, 'utf8');
+  const parsed = yaml.load(content);
+  return parsed.runs.steps[0].with.script;
+}
+
+module.exports = { extractScript };

test/jest.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  testMatch: ['**/*.test.js'],
+};