Add unit tests

Author: axel-op

.github/workflows/compile.yml

@@ -15,7 +15,7 @@ jobs:
       - name: Compile with ncc
         run: |
           npm install
-          npx ncc build index.ts -o dist
+          npx ncc build src/index.ts -o dist
       - name: Push
         env:
           DIR: dist

.github/workflows/test.yml

@@ -3,6 +3,18 @@ name: Test
 on: [push, pull_request]
 
 jobs:
+  unit-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - name: Test
+        run: |
+          npm install
+          npm test
+
   tests-with-token:
     if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.owner.login == 'axel-op'
     strategy:

__tests__/exec.test.ts

@@ -0,0 +1,50 @@
+import { expect, jest, test } from '@jest/globals';
+import { ExecOptions } from '@actions/exec';
+import { wrapExecutor } from '../src/exec';
+
+function mockWrappedExec(returnCode: number, std: { stdOut: string, stdErr: string }) {
+    return jest.fn((command: string, args?: string[], options?: ExecOptions) => {
+        options?.listeners?.stdout?.(Buffer.from(std.stdOut));
+        options?.listeners?.stderr?.(Buffer.from(std.stdErr));
+        return Promise.resolve(returnCode);
+    });
+}
+
+test('test executing command with no error', async () => {
+    const stdOut = 'hello world';
+    const stdErr = '';
+    const exitCode = 0;
+    const mockedWrapped = mockWrappedExec(exitCode, { stdOut, stdErr });
+    const execute = wrapExecutor(mockedWrapped);
+    const command = 'echo';
+    const args = ['hello world'];
+    const result = await execute(command, args);
+    expect(result).toEqual({ exitCode, stdOut, stdErr });
+    expect(mockedWrapped).toHaveBeenCalledTimes(1);
+});
+
+test('test executing command with error and ignoring return code', async () => {
+    const stdOut = 'hello world';
+    const stdErr = '';
+    const exitCode = 1;
+    const mockedWrapped = mockWrappedExec(exitCode, { stdOut, stdErr });
+    const execute = wrapExecutor(mockedWrapped);
+    const command = 'echo';
+    const args = ['hello world'];
+    const result = await execute(command, args);
+    expect(result).toEqual({ exitCode, stdOut, stdErr });
+    expect(mockedWrapped).toHaveBeenCalledTimes(1);
+});
+
+test('test executing command with error and not ignoring return code', async () => {
+    const stdOut = 'hello world';
+    const stdErr = '';
+    const exitCode = 1;
+    const mockedWrapped = mockWrappedExec(exitCode, { stdOut, stdErr });
+    const execute = wrapExecutor(mockedWrapped);
+    const command = 'echo';
+    const args = ['hello world'];
+    const fn = async () => await execute(command, args, { ignoreReturnCode: false });
+    await expect(fn).rejects.toThrow(new Error("Command 'echo hello world' failed with exit code 1"));
+    expect(mockedWrapped).toHaveBeenCalledTimes(1);
+});

__tests__/main.test.ts

@@ -0,0 +1,300 @@
+import { afterEach, beforeEach, describe, expect, jest, test } from '@jest/globals';
+import { getInput, Main } from '../src/main';
+import { CommandExecutor } from '../src/exec';
+import { ReleaseData, Releases } from '../src/releases';
+import { GitOperations } from '../src/git';
+
+const mockGetLatestReleaseData = jest.fn<InstanceType<typeof Releases>['getLatestReleaseData']>();
+const mockGetReleaseDataByName = jest.fn<InstanceType<typeof Releases>['getReleaseDataByName']>();
+jest.mock('../src/releases', () => {
+    return {
+        Releases: jest.fn().mockImplementation(() => {
+            return {
+                getLatestReleaseData: mockGetLatestReleaseData,
+                getReleaseDataByName: mockGetReleaseDataByName,
+            }
+        }),
+    };
+});
+
+const mockHasChanges = jest.fn<InstanceType<typeof GitOperations>['hasChanges']>();
+const mockCommitAll = jest.fn<InstanceType<typeof GitOperations>['commitAll']>();
+const mockPush = jest.fn<InstanceType<typeof GitOperations>['push']>();
+jest.mock('../src/git', () => {
+    return {
+        GitOperations: jest.fn().mockImplementation(() => {
+            return {
+                configureGit: () => { },
+                commitAll: mockCommitAll,
+                hasChanges: mockHasChanges,
+                push: mockPush,
+            }
+        }),
+    };
+});
+
+const executor = jest.fn<CommandExecutor>();
+
+beforeEach(() => {
+    executor.mockReset();
+});
+
+const dummyReleaseData: ReleaseData = {
+    url: "",
+    html_url: "",
+    assets_url: "",
+    upload_url: "",
+    tarball_url: null,
+    zipball_url: null,
+    id: 0,
+    node_id: "",
+    tag_name: "",
+    target_commitish: "",
+    name: "dummy-release-data",
+    draft: false,
+    prerelease: false,
+    created_at: "",
+    published_at: null,
+    author: {
+        name: undefined,
+        email: undefined,
+        login: "",
+        id: 0,
+        node_id: "",
+        avatar_url: "",
+        gravatar_id: null,
+        url: "",
+        html_url: "",
+        followers_url: "",
+        following_url: "",
+        gists_url: "",
+        starred_url: "",
+        subscriptions_url: "",
+        organizations_url: "",
+        repos_url: "",
+        events_url: "",
+        received_events_url: "",
+        type: "",
+        site_admin: false,
+        starred_at: undefined
+    },
+    assets: []
+};
+
+function defineInput(inputName: string, inputValue?: string) {
+    process.env[`INPUT_${inputName.toUpperCase()}`] = inputValue;
+}
+
+describe('test getting inputs', () => {
+    const existingInputName = "my-input";
+    const existingInputValue = "my-input-value";
+
+    beforeEach(() => {
+        defineInput(existingInputName, existingInputValue);
+    });
+
+    afterEach(() => {
+        defineInput(existingInputName, undefined);
+    });
+
+    test('test getting existing input value', () => {
+        const value = getInput([existingInputName, "non-existing-input"]);
+        expect(value).toBe(existingInputValue);
+    });
+
+    test('test getting existing input value with fallback input name', () => {
+        const value = getInput(["input_name_one", existingInputName]);
+        expect(value).toBe(existingInputValue);
+    });
+
+    test('test getting non existing input value', () => {
+        const inputName = "my-non-existing-input";
+        const value = getInput([inputName]);
+        expect(value).toBeUndefined();
+    });
+});
+
+describe('test getting Java version', () => {
+    const main = new Main(executor);
+
+    test('test invalid return code', () => {
+        const error = new Error("Command 'java -version' failed with exit code 1");
+        executor.mockReturnValueOnce(Promise.reject(error));
+        expect(() => main.getJavaVersion())
+            .rejects
+            .toThrow(error);
+        expect(executor).lastCalledWith('java', ['-version'], { ignoreReturnCode: false, silent: true });
+    });
+
+    test('test no output', () => {
+        executor.mockReturnValueOnce(Promise.resolve({
+            exitCode: 0,
+            stdErr: '',
+            stdOut: '',
+        }));
+        expect(() => main.getJavaVersion())
+            .rejects
+            .toThrow(new Error("Cannot find Java version number"));
+        expect(executor).lastCalledWith('java', ['-version'], { ignoreReturnCode: false, silent: true });
+    });
+
+    test('test version <= JDK 8', () => {
+        executor.mockReturnValueOnce(Promise.resolve({
+            exitCode: 0,
+            stdErr: 'java version "1.8.0_211"',
+            stdOut: '',
+        }));
+        expect(main.getJavaVersion())
+            .resolves
+            .toBe(8);
+        expect(executor).lastCalledWith('java', ['-version'], { ignoreReturnCode: false, silent: true });
+    });
+
+    test('test version > JDK 8', () => {
+        executor.mockReturnValueOnce(Promise.resolve({
+            exitCode: 0,
+            stdErr: 'openjdk version "21.0.6" 2025-01-21',
+            stdOut: '',
+        }));
+        expect(main.getJavaVersion())
+            .resolves
+            .toBe(21);
+        expect(executor).lastCalledWith('java', ['-version'], { ignoreReturnCode: false, silent: true });
+    });
+});
+
+describe('test getting release data', () => {
+    test('if no release name and java version >= 11, then return latest release', async () => {
+        const main = new Main(executor);
+        mockGetLatestReleaseData.mockReturnValueOnce(Promise.resolve(dummyReleaseData));
+        const releaseData = await main.getReleaseData(11, undefined);
+        expect(releaseData).toEqual(dummyReleaseData);
+    });
+
+    test('if no release name and java version < 11, then return release 1.7', async () => {
+        const main = new Main(executor);
+        mockGetReleaseDataByName.mockReturnValueOnce(Promise.resolve(dummyReleaseData));
+        const releaseData = await main.getReleaseData(8, undefined);
+        expect(releaseData).toEqual(dummyReleaseData);
+        expect(mockGetReleaseDataByName).lastCalledWith('1.7');
+    });
+
+    test('if release name, then return it', async () => {
+        const releaseName = 'my-release';
+        const main = new Main(executor);
+        mockGetReleaseDataByName.mockReturnValueOnce(Promise.resolve(dummyReleaseData));
+        const releaseData = await main.getReleaseData(11, releaseName);
+        expect(releaseData).toEqual(dummyReleaseData);
+        expect(mockGetReleaseDataByName).lastCalledWith(releaseName);
+    });
+
+    test('if release not found, then throw', async () => {
+        const releaseName = 'my-release';
+        defineInput('version', releaseName);
+        const main = new Main(executor);
+        mockGetReleaseDataByName.mockReturnValueOnce(Promise.resolve(undefined));
+        expect(() => main.getReleaseData(11, releaseName))
+            .rejects
+            .toThrow(new Error(`Cannot find release id of Google Java Format ${releaseName}`));
+        expect(mockGetReleaseDataByName).lastCalledWith(releaseName);
+    });
+});
+
+describe('test getting args', () => {
+    const main = new Main(executor);
+
+    test('if input has args, then output has them too', async () => {
+        const inputs = { args: ['--replace'], files: '**/*.java', filesExcluded: undefined };
+        const output = await main.getGJFArgs(inputs);
+        expect(output).toEqual(['--replace']);
+    });
+
+    test('files matching glob are appended to output', async () => {
+        const inputs = { args: ['--replace'], files: '*.md', filesExcluded: undefined };
+        const output = await main.getGJFArgs(inputs);
+        expect(output).toHaveLength(2);
+        expect(output[0]).toEqual('--replace');
+        expect(output[1]).toMatch(/^.*README\.md$/);
+    });
+
+    test('if input has exclusion glob, then output excludes matching files', async () => {
+        const inputs = { args: ['--replace'], files: '*.md', filesExcluded: '*.md' };
+        const output = await main.getGJFArgs(inputs);
+        expect(output).toEqual(['--replace']);
+    })
+});
+
+describe('commit changes', () => {
+    const githubToken = '***';
+    defineInput('github-token', githubToken);
+    const main = new Main(executor);
+
+    test('if there is no change, then skip commit', async () => {
+        mockHasChanges.mockReturnValueOnce(Promise.resolve(false));
+        await main.commitChanges({ githubActor: '', repository: '', commitMessage: undefined, });
+        expect(mockCommitAll).not.toBeCalled();
+        expect(mockPush).not.toBeCalled();
+    });
+
+    test('if there are changes, but no commit message, then commit with default message', async () => {
+        mockHasChanges.mockReturnValueOnce(Promise.resolve(true));
+        const githubActor = "actor";
+        const repository = "actor/repo";
+        await main.commitChanges({ githubActor, repository, commitMessage: undefined });
+        expect(mockCommitAll).toHaveBeenCalledWith('Google Java Format');
+        expect(mockPush).toBeCalledWith({ githubActor, repository, githubToken });
+    });
+
+    test('if there are changes, and a commit message, then commit with message', async () => {
+        mockHasChanges.mockReturnValueOnce(Promise.resolve(true));
+        const githubActor = "actor";
+        const repository = "actor/repo";
+        const commitMessage = "my message";
+        await main.commitChanges({ githubActor, repository, commitMessage });
+        expect(mockCommitAll).toHaveBeenCalledWith(commitMessage);
+        expect(mockPush).toBeCalledWith({ githubActor, repository, githubToken });
+    });
+});
+
+describe('execute Google Java Format', () => {
+    const executablePath = 'google-java-format.jar';
+    const main = new Main(executor, executablePath);
+    
+    test('when running GJF, then pass user args to command', async () => {
+        const mockedResult = { exitCode: 0, stdErr: '', stdOut: '' };
+        executor.mockReturnValueOnce(Promise.resolve(mockedResult));
+        const args = ['a', 'b', 'c'];
+        const result = await main.executeGJF(8, args);
+        expect(result).toEqual(mockedResult);
+        expect(executor).lastCalledWith('java', ['-jar', executablePath, 'a', 'b', 'c'], { ignoreReturnCode: false });
+    });
+
+    test('when running GJF with java version >= 11, then exports required jdk modules', async () => {
+        const mockedResult = { exitCode: 0, stdErr: '', stdOut: '' };
+        executor.mockReturnValueOnce(Promise.resolve(mockedResult));
+        const args = ['a', 'b', 'c'];
+        const result = await main.executeGJF(11, args);
+        expect(result).toEqual(mockedResult);
+        expect(executor).lastCalledWith(
+            'java',
+            [
+                '--add-exports',
+                'jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED',
+                '--add-exports',
+                'jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED',
+                '--add-exports',
+                'jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED',
+                '--add-exports',
+                'jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED',
+                '--add-exports',
+                'jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED',
+                '-jar',
+                executablePath,
+                'a',
+                'b',
+                'c',
+            ],
+            { ignoreReturnCode: false }
+        );
+    });
+});