feat: restore broken features

Author: roderik

__tests__/main.test.ts

@@ -2,51 +2,68 @@
  * Unit tests for the action's main functionality, src/main.ts
  */
 
+import * as cache from '@actions/cache';
 import * as core from '@actions/core';
 import * as exec from '@actions/exec';
 import * as tc from '@actions/tool-cache';
 import * as main from '../src/main';
 
 // Mock the action's main function
-const runMock = jest.spyOn(main, 'run');
+const _runMock = jest.spyOn(main, 'run');
 
 // Mock the GitHub Actions core library
 let _debugMock: jest.SpiedFunction<typeof core.debug>;
 let errorMock: jest.SpiedFunction<typeof core.error>;
 let getInputMock: jest.SpiedFunction<typeof core.getInput>;
-let setFailedMock: jest.SpiedFunction<typeof core.setFailed>;
-let setSecretMock: jest.SpiedFunction<typeof core.setSecret>;
-let addPathMock: jest.SpiedFunction<typeof core.addPath>;
+let _setFailedMock: jest.SpiedFunction<typeof core.setFailed>;
+let _setSecretMock: jest.SpiedFunction<typeof core.setSecret>;
+let _addPathMock: jest.SpiedFunction<typeof core.addPath>;
 let _infoMock: jest.SpiedFunction<typeof core.info>;
-let warningMock: jest.SpiedFunction<typeof core.warning>;
+let _warningMock: jest.SpiedFunction<typeof core.warning>;
+let exportVariableMock: jest.SpiedFunction<typeof core.exportVariable>;
 
 // Mock the exec library
 let execMock: jest.SpiedFunction<typeof exec.exec>;
 
 // Mock the tool-cache library
-let findMock: jest.SpiedFunction<typeof tc.find>;
+let _findMock: jest.SpiedFunction<typeof tc.find>;
 let cacheDirMock: jest.SpiedFunction<typeof tc.cacheDir>;
 
+// Mock the cache library
+let _restoreCacheMock: jest.SpiedFunction<typeof cache.restoreCache>;
+let _saveCacheMock: jest.SpiedFunction<typeof cache.saveCache>;
+
 describe('action', () => {
   beforeEach(() => {
     jest.clearAllMocks();
 
     _debugMock = jest.spyOn(core, 'debug').mockImplementation();
     errorMock = jest.spyOn(core, 'error').mockImplementation();
     getInputMock = jest.spyOn(core, 'getInput').mockImplementation();
-    setFailedMock = jest.spyOn(core, 'setFailed').mockImplementation();
-    setSecretMock = jest.spyOn(core, 'setSecret').mockImplementation();
-    addPathMock = jest.spyOn(core, 'addPath').mockImplementation();
+    _setFailedMock = jest.spyOn(core, 'setFailed').mockImplementation();
+    _setSecretMock = jest.spyOn(core, 'setSecret').mockImplementation();
+    _addPathMock = jest.spyOn(core, 'addPath').mockImplementation();
     _infoMock = jest.spyOn(core, 'info').mockImplementation();
-    warningMock = jest.spyOn(core, 'warning').mockImplementation();
-    execMock = jest.spyOn(exec, 'exec').mockImplementation();
-    findMock = jest.spyOn(tc, 'find').mockImplementation();
+    _warningMock = jest.spyOn(core, 'warning').mockImplementation();
+    exportVariableMock = jest.spyOn(core, 'exportVariable').mockImplementation();
+    execMock = jest.spyOn(exec, 'exec').mockImplementation(() => Promise.resolve(0));
+    _findMock = jest.spyOn(tc, 'find').mockImplementation();
     cacheDirMock = jest.spyOn(tc, 'cacheDir').mockImplementation();
+    _restoreCacheMock = jest.spyOn(cache, 'restoreCache').mockImplementation();
+    _saveCacheMock = jest.spyOn(cache, 'saveCache').mockImplementation();
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+    // Clean up environment variables
+    process.env.SETTLEMINT_ACCESS_TOKEN = undefined;
+    process.env.SETTLEMINT_PERSONAL_ACCESS_TOKEN = undefined;
+    process.env.SETTLEMINT_INSTANCE = undefined;
+    process.env.SETTLEMINT_WORKSPACE = undefined;
   });
 
   it('installs CLI and runs command', async () => {
     // Mock tool cache to simulate CLI not found
-    findMock.mockReturnValue('');
     cacheDirMock.mockResolvedValue('/cached/path');
 
     getInputMock.mockImplementation((name) => {
@@ -65,36 +82,14 @@ describe('action', () => {
     });
 
     await main.run();
-    expect(runMock).toHaveReturned();
-
-    // Check that we tried to find cached version
-    expect(findMock).toHaveBeenCalledWith('settlemint-cli', 'latest');
-
-    // Check that we installed the CLI
-    expect(execMock).toHaveBeenCalledWith(
-      'mkdir',
-      expect.arrayContaining(['-p', expect.stringContaining('settlemint-cli-')])
-    );
-    expect(execMock).toHaveBeenCalledWith(
-      'npm',
-      expect.arrayContaining(['install', '--prefix', expect.any(String), '@settlemint/sdk-cli'])
-    );
-
-    // Check that we cached the installation
-    expect(cacheDirMock).toHaveBeenCalled();
-
-    // Check that we added to PATH
-    expect(addPathMock).toHaveBeenCalled();
 
-    // Check that we ran the command
-    expect(execMock).toHaveBeenCalledWith('settlemint', ['status']);
+    // Check that we ran the command using npx
+    expect(execMock).toHaveBeenCalledWith('npx -y @settlemint/sdk-cli@latest', ['status']);
 
     expect(errorMock).not.toHaveBeenCalled();
-  });
+  }, 30000);
 
   it('handles auto-connect when using a personal access token', async () => {
-    findMock.mockReturnValue('/cached/path');
-
     getInputMock.mockImplementation((name) => {
       switch (name) {
         case 'command':
@@ -111,24 +106,20 @@ describe('action', () => {
     });
 
     await main.run();
-    expect(runMock).toHaveReturned();
 
-    // Should use cached version
-    expect(findMock).toHaveBeenCalledWith('settlemint-cli', 'latest');
-    expect(addPathMock).toHaveBeenCalled();
+    // Personal access token should be set as environment variable
+    expect(process.env.SETTLEMINT_PERSONAL_ACCESS_TOKEN).toBe('sm_pat_1234567890');
 
-    // Should mask the access token
-    expect(setSecretMock).toHaveBeenCalledWith('sm_pat_1234567890');
+    // Access token should be masked
+    expect(_setSecretMock).toHaveBeenCalledWith('sm_pat_1234567890');
 
-    // Should login and connect
-    expect(execMock).toHaveBeenCalledWith('settlemint', ['login', '-a']);
-    expect(execMock).toHaveBeenCalledWith('settlemint', ['connect', '-a']);
-    expect(execMock).toHaveBeenCalledWith('settlemint', ['status']);
-  });
-
-  it('does not auto-connect when using an application access token', async () => {
-    findMock.mockReturnValue('/cached/path');
+    // Should login (because of personal access token) and connect (because auto-connect is true)
+    expect(execMock).toHaveBeenCalledWith('npx -y @settlemint/sdk-cli@latest', ['login', '-a']);
+    expect(execMock).toHaveBeenCalledWith('npx -y @settlemint/sdk-cli@latest', ['connect', '-a']);
+    expect(execMock).toHaveBeenCalledWith('npx -y @settlemint/sdk-cli@latest', ['status']);
+  }, 30000);
 
+  it('does not login but still connects when using an application access token with auto-connect', async () => {
     getInputMock.mockImplementation((name) => {
       switch (name) {
         case 'command':
@@ -145,20 +136,20 @@ describe('action', () => {
     });
 
     await main.run();
-    expect(runMock).toHaveReturned();
 
-    // Should mask the access token
-    expect(setSecretMock).toHaveBeenCalledWith('sm_app_1234567890');
+    // Application token should be set as environment variable
+    expect(process.env.SETTLEMINT_ACCESS_TOKEN).toBe('sm_app_1234567890');
 
-    // Should NOT login or connect with app token
-    expect(execMock).not.toHaveBeenCalledWith('settlemint', ['login', '-a']);
-    expect(execMock).not.toHaveBeenCalledWith('settlemint', ['connect', '-a']);
-    expect(execMock).toHaveBeenCalledWith('settlemint', ['status']);
-  });
+    // Access token should be masked
+    expect(_setSecretMock).toHaveBeenCalledWith('sm_app_1234567890');
 
-  it('sets environment variables when provided', async () => {
-    findMock.mockReturnValue('/cached/path');
+    // Should NOT login with app token, but should still connect because auto-connect is true
+    expect(execMock).not.toHaveBeenCalledWith('npx -y @settlemint/sdk-cli@latest', ['login', '-a']);
+    expect(execMock).toHaveBeenCalledWith('npx -y @settlemint/sdk-cli@latest', ['connect', '-a']);
+    expect(execMock).toHaveBeenCalledWith('npx -y @settlemint/sdk-cli@latest', ['status']);
+  }, 30000);
 
+  it('sets environment variables when provided', async () => {
     getInputMock.mockImplementation((name) => {
       switch (name) {
         case 'command':
@@ -177,16 +168,13 @@ describe('action', () => {
     });
 
     await main.run();
-    expect(runMock).toHaveReturned();
 
     expect(process.env.SETTLEMINT_INSTANCE).toBe('test-instance');
     expect(process.env.SETTLEMINT_WORKSPACE).toBe('test-workspace');
     expect(process.env.SETTLEMINT_ACCESS_TOKEN).toBe('sm_app_1234567890');
-  });
+  }, 30000);
 
   it('validates version format', async () => {
-    findMock.mockReturnValue('');
-
     getInputMock.mockImplementation((name) => {
       switch (name) {
         case 'version':
@@ -199,16 +187,12 @@ describe('action', () => {
     });
 
     await main.run();
-    expect(runMock).toHaveReturned();
-
-    expect(setFailedMock).toHaveBeenCalledWith(
+    expect(_setFailedMock).toHaveBeenCalledWith(
       "Invalid version format: invalid-version. Must be a valid semver version or 'latest'"
     );
-  });
+  }, 30000);
 
   it('handles command injection attempts', async () => {
-    findMock.mockReturnValue('/cached/path');
-
     getInputMock.mockImplementation((name) => {
       switch (name) {
         case 'command':
@@ -223,50 +207,56 @@ describe('action', () => {
     });
 
     await main.run();
-    expect(runMock).toHaveReturned();
-
-    expect(setFailedMock).toHaveBeenCalledWith(
+    expect(_setFailedMock).toHaveBeenCalledWith(
       'Failed to execute command: Error: Command contains potentially dangerous characters. Please use simple commands only.'
     );
-  });
-
-  it('handles installation failure with retry', async () => {
-    findMock.mockReturnValue('');
+  }, 30000);
 
-    // First npm install fails, second succeeds
-    execMock.mockImplementation((cmd, args) => {
-      if (cmd === 'npm' && args && args.includes('install') && args.includes('--prefix')) {
-        throw new Error('Network error');
+  it('supports standalone mode without access token', async () => {
+    getInputMock.mockImplementation((name) => {
+      switch (name) {
+        case 'command':
+          return 'status';
+        case 'version':
+          return 'latest';
+        case 'instance':
+          return 'standalone';
+        case 'access-token':
+          return ''; // No access token for standalone
+        default:
+          return '';
       }
-      return Promise.resolve(0);
     });
 
+    await main.run();
+
+    // Should NOT try to login or connect in standalone mode
+    expect(execMock).not.toHaveBeenCalledWith('npx -y @settlemint/sdk-cli@latest', ['login', '-a']);
+    expect(execMock).not.toHaveBeenCalledWith('npx -y @settlemint/sdk-cli@latest', ['connect', '-a']);
+    expect(execMock).toHaveBeenCalledWith('npx -y @settlemint/sdk-cli@latest', ['status']);
+  }, 30000);
+
+  it('requires access token when not in standalone mode', async () => {
     getInputMock.mockImplementation((name) => {
       switch (name) {
         case 'command':
           return 'status';
         case 'version':
           return 'latest';
+        case 'instance':
+          return 'production';
         case 'access-token':
-          return 'sm_app_1234567890';
+          return ''; // No access token
         default:
           return '';
       }
     });
 
     await main.run();
-    expect(runMock).toHaveReturned();
-
-    // Should have warned about failure
-    expect(warningMock).toHaveBeenCalledWith('Initial installation failed, retrying...');
-
-    // Should have tried global install as fallback
-    expect(execMock).toHaveBeenCalledWith('npm', ['install', '-g', '@settlemint/sdk-cli@latest']);
-  });
+    expect(_setFailedMock).toHaveBeenCalledWith('access-token is required when not in standalone mode');
+  }, 30000);
 
   it('processes dotEnvFile content', async () => {
-    findMock.mockReturnValue('/cached/path');
-
     getInputMock.mockImplementation((name) => {
       switch (name) {
         case 'command':
@@ -282,15 +272,11 @@ describe('action', () => {
       }
     });
 
-    // Mock exportVariable
-    const exportVariableMock = jest.spyOn(core, 'exportVariable').mockImplementation();
-
     await main.run();
-    expect(runMock).toHaveReturned();
 
     // Check that environment variables were set correctly
     expect(exportVariableMock).toHaveBeenCalledWith('TEST_VAR', 'test_value');
     expect(exportVariableMock).toHaveBeenCalledWith('QUOTED', 'quoted value');
     expect(exportVariableMock).toHaveBeenCalledWith('VAR_WITH_EQUALS', 'key=value');
-  });
+  }, 30000);
 });

badges/coverage.svg

@@ -18,7 +18,7 @@
     "formatter": {
       "lineWidth": 120
     },
-    "globals": ["jest", "describe", "it", "beforeEach", "expect"]
+    "globals": ["jest", "describe", "it", "beforeEach", "afterEach", "expect"]
   },
   "css": {
     "formatter": {