refactor(util): Eliminate side-effects on import

Move the util.promisify() call in src/util.ts from the top level to
execBashCommand(). Mock util.promisify() in tests now that it is simpler
to do so before util.promisify() is called. Introduce src/mocks/util.ts
to share the util mock factory between tests.

src/integration.test.ts

@@ -1,21 +1,22 @@
+import { exec } from "node:child_process";
 import { testProp } from "@fast-check/jest";
 import { jest } from "@jest/globals";
 import { string } from "fast-check";
 
 import { consoleOutput } from "./arbitraries/util.js";
+import { utilFactory } from "./mocks/util.js";
 
-import type { exec, ExecOptions } from "node:child_process";
+import type { ExecOptions } from "node:child_process";
 import type { InputOptions } from "@actions/core";
+import type { Mock } from "jest-mock";
 
 import type { ConsoleOutput } from "./util.js";
 
-jest.unstable_mockModule("node:child_process", () => ({
-  exec: jest.fn<typeof exec>(),
-}));
+jest.unstable_mockModule("node:util", utilFactory);
 jest.mock("@actions/cache");
 jest.mock("@actions/core");
 
-const child_process = jest.mocked(await import("node:child_process"));
+const nodeUtil = jest.mocked(await import("node:util"));
 const cache = jest.mocked(await import("@actions/cache"));
 const core = jest.mocked(await import("@actions/core"));
 const docker = await import("./docker.js");
@@ -33,6 +34,7 @@ describe("Integration Test", (): void => {
   let state: Record<string, string>;
   let dockerImages: string[];
   let callCount: number;
+  let execMock: Mock<(command: string) => Promise<ConsoleOutput>>;
 
   beforeEach(async (): Promise<void> => {
     loadCommand = `docker load --input ${docker.DOCKER_IMAGES_PATH}`;
@@ -64,11 +66,7 @@ describe("Integration Test", (): void => {
   });
 
   const mockExec = (listStderr: string, otherOutput: ConsoleOutput): void => {
-    child_process.exec.mockImplementation(<typeof exec>((
-      command: string,
-      _options: any,
-      callback: any
-    ): any => {
+    execMock = jest.fn((command: string): Promise<ConsoleOutput> => {
       let output: ConsoleOutput;
       if (command === LIST_COMMAND) {
         /* When Docker is running as root, docker image list generates a list
@@ -85,8 +83,10 @@ describe("Integration Test", (): void => {
       } else {
         output = otherOutput;
       }
-      callback(null, output);
-    }));
+      return Promise.resolve(output);
+    });
+
+    nodeUtil.promisify.mockReturnValue(execMock);
   };
 
   const assertExecBashCommand = (
@@ -96,11 +96,11 @@ describe("Integration Test", (): void => {
     output: ConsoleOutput
   ): void => {
     expect(core.info).nthCalledWith<[string]>(infoCallNum, command);
-    expect(child_process.exec).nthCalledWith<[string, ExecOptions, any]>(
+    expect(nodeUtil.promisify).nthCalledWith<[typeof exec]>(execCallNum, exec);
+    expect(execMock).nthCalledWith<[string, ExecOptions]>(
       execCallNum,
       command,
-      EXEC_OPTIONS,
-      expect.anything()
+      EXEC_OPTIONS
     );
     expect(core.info).nthCalledWith<[string]>(infoCallNum + 1, output.stdout);
     expect(core.error).nthCalledWith<[string]>(execCallNum, output.stderr);
@@ -128,14 +128,14 @@ describe("Integration Test", (): void => {
       const listOutput = joinOutput(dockerImages, listStderr);
       assertExecBashCommand(2, 1, LIST_COMMAND, listOutput);
     }
-    expect(child_process.exec).toHaveBeenCalledTimes(1);
+    expect(execMock).toHaveBeenCalledTimes(1);
   };
 
   const assertSaveCacheHit = (key: string): void => {
     expect(core.info).lastCalledWith(
       `Cache hit occurred on the primary key ${key}, not saving cache.`
     );
-    expect(child_process.exec).not.toHaveBeenCalled();
+    expect(execMock).not.toHaveBeenCalled();
     expect(core.setFailed).not.toHaveBeenCalled();
     expect(cache.saveCache).not.toHaveBeenCalled();
   };

src/mocks/util.ts

@@ -0,0 +1,9 @@
+import { jest } from "@jest/globals";
+
+import type { promisify } from "node:util";
+
+export const utilFactory = (): {
+  promisify: Omit<typeof promisify, "custom">;
+} => ({
+  promisify: jest.fn<typeof promisify>(),
+});

src/util.test.ts

@@ -1,20 +1,17 @@
+import { exec } from "node:child_process";
 import { testProp } from "@fast-check/jest";
 import { jest } from "@jest/globals";
 import { string } from "fast-check";
 
 import { consoleOutput, platform } from "./arbitraries/util.js";
-
-import type { exec } from "node:child_process";
+import { utilFactory } from "./mocks/util.js";
 
 import type { ConsoleOutput } from "./util.js";
 
-jest.unstable_mockModule("node:child_process", () => ({
-  exec: jest.fn<typeof exec>(),
-}));
-
+jest.unstable_mockModule("node:util", utilFactory);
 jest.mock("@actions/core");
 
-const child_process = jest.mocked(await import("node:child_process"));
+const nodeUtil = jest.mocked(await import("node:util"));
 const core = jest.mocked(await import("@actions/core"));
 const util = await import("./util.js");
 
@@ -26,25 +23,22 @@ describe("Util", (): void => {
       platform: NodeJS.Platform,
       output: ConsoleOutput
     ): Promise<string> => {
-      child_process.exec.mockImplementationOnce(<typeof exec>((
-        _command: any,
-        _options: any,
-        callback: any
-      ): any => {
-        callback(error, output);
-      }));
+      const execMock = jest.fn(
+        (): Promise<ConsoleOutput> =>
+          error ? Promise.reject(error) : Promise.resolve(output)
+      );
+
+      nodeUtil.promisify.mockReturnValueOnce(execMock);
+
       const stdout = await util.execBashCommand(command, platform);
 
       expect(core.info).nthCalledWith<[string]>(1, command);
+      expect(nodeUtil.promisify).lastCalledWith(exec);
       const shell =
         platform === "win32"
           ? "C:\\Program Files\\Git\\bin\\bash.exe"
           : "/usr/bin/bash";
-      expect(child_process.exec).lastCalledWith(
-        command,
-        { shell },
-        expect.anything()
-      );
+      expect(execMock).lastCalledWith(command, { shell });
       return stdout;
     };
 

src/util.ts

@@ -1,6 +1,5 @@
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
-const execAsPromised = promisify(exec);
 
 import { error, info, setFailed } from "@actions/core";
 
@@ -14,6 +13,7 @@ const execBashCommand = async (
   platform: NodeJS.Platform = process.platform
 ): Promise<string> => {
   info(command);
+  const execAsPromised = promisify(exec);
   const shell =
     platform === "win32"
       ? "C:\\Program Files\\Git\\bin\\bash.exe"