chore: replace jest mock with dep injection

We can't mock that way with esm dependencies[^1]. There are some
workarounds, but nothing worked, so I decided to introduce my own
interface and dependency injection.

In the `exec` module, apparently, we used to do it this way; there was
an old (unused) `ExecDelegate` interface. When implementing `withCache`,
I tried to follow that naming and test definition style, balanced
against reducing the diff with `main`.

[^1]: jestjs/jest#10025

Author: pbrisbin

src/stack-cli.test.ts

@@ -1,13 +1,17 @@
-import * as exec from "@actions/exec";
+import { ExecOptions } from "@actions/exec";
 import { jest } from "@jest/globals";
 
-import { StackCLI } from "./stack-cli.js";
+import { ExecDelegate, StackCLI } from "./stack-cli.js";
 
-jest.spyOn(exec, "exec");
+const exec: ExecDelegate = {
+  exec: jest.fn((command: string, args: string[], options?: ExecOptions) =>
+    Promise.resolve(0),
+  ),
+};
 
 describe("StackCLI", () => {
   test("Respects --resolver given", async () => {
-    const stackCLI = new StackCLI(["--resolver", "lts"], false);
+    const stackCLI = new StackCLI(["--resolver", "lts"], false, exec);
 
     await stackCLI.setup([]);
 
@@ -22,6 +26,7 @@ describe("StackCLI", () => {
     const stackCLI = new StackCLI(
       ["--stack-yaml", "sub/stack-nightly.yaml"],
       false,
+      exec,
     );
 
     await stackCLI.setup([]);
@@ -48,6 +53,7 @@ describe("StackCLI", () => {
         "nightly-20240201",
       ],
       false,
+      exec,
     );
 
     await stackCLI.setup([]);
@@ -66,7 +72,7 @@ describe("StackCLI", () => {
   });
 
   test("installCompilerTools", async () => {
-    const stackCLI = new StackCLI([], false);
+    const stackCLI = new StackCLI([], false, exec);
     await stackCLI.installCompilerTools(["hlint", "weeder"]);
 
     expect(exec.exec).toHaveBeenCalledWith(
@@ -77,14 +83,14 @@ describe("StackCLI", () => {
   });
 
   test("installCompilerTools with empty arguments", async () => {
-    const stackCLI = new StackCLI([], false);
+    const stackCLI = new StackCLI([], false, exec);
     await stackCLI.installCompilerTools([]);
 
     expect(exec.exec).not.toHaveBeenCalled();
   });
 
   test("buildDependencies", async () => {
-    const stackCLI = new StackCLI([], false);
+    const stackCLI = new StackCLI([], false, exec);
 
     await stackCLI.buildDependencies(["--coverage"]);
 
@@ -102,7 +108,7 @@ describe("StackCLI", () => {
   });
 
   test("buildNoTest", async () => {
-    const stackCLI = new StackCLI([], false);
+    const stackCLI = new StackCLI([], false, exec);
 
     await stackCLI.buildNoTest(["--coverage"]);
 
@@ -114,7 +120,7 @@ describe("StackCLI", () => {
   });
 
   test("buildTest", async () => {
-    const stackCLI = new StackCLI([], false);
+    const stackCLI = new StackCLI([], false, exec);
 
     await stackCLI.buildTest(["--coverage"]);
 
@@ -126,7 +132,7 @@ describe("StackCLI", () => {
   });
 
   test("build", async () => {
-    const stackCLI = new StackCLI([], false);
+    const stackCLI = new StackCLI([], false, exec);
 
     await stackCLI.build(["--coverage"]);
 

src/stack-cli.ts

@@ -2,12 +2,12 @@ import * as fs from "fs";
 import * as path from "path";
 import { devNull } from "os";
 import type { ExecOptions } from "@actions/exec";
-import * as exec from "@actions/exec";
+import * as realExec from "@actions/exec";
 
-import type { StackPath } from "./parse-stack-path.js"
-import { parseStackPath } from "./parse-stack-path.js"
-import type { StackQuery } from "./parse-stack-query.js"
-import { parseStackQuery } from "./parse-stack-query.js"
+import type { StackPath } from "./parse-stack-path.js";
+import { parseStackPath } from "./parse-stack-path.js";
+import type { StackQuery } from "./parse-stack-query.js";
+import { parseStackQuery } from "./parse-stack-query.js";
 
 export interface ExecDelegate {
   exec: (
@@ -23,10 +23,12 @@ export class StackCLI {
 
   private debug: boolean;
   private globalArgs: string[];
+  private execImpl: ExecDelegate;
 
-  constructor(args: string[], debug?: boolean) {
+  constructor(args: string[], debug?: boolean, exec?: ExecDelegate) {
     this.debug = debug ?? false;
     this.globalArgs = args;
+    this.execImpl = exec ?? realExec;
 
     // Capture --stack-yaml if given
     const stackYamlIdx = args.indexOf("--stack-yaml");
@@ -49,7 +51,7 @@ export class StackCLI {
   }
 
   async installed(): Promise<boolean> {
-    const ec = await exec.exec("which", ["stack"], {
+    const ec = await this.execImpl.exec("which", ["stack"], {
       silent: true,
       ignoreReturnCode: true,
     });
@@ -59,14 +61,14 @@ export class StackCLI {
   async install(): Promise<void> {
     const url = "https://get.haskellstack.org";
     const tmp = "install-stack.sh";
-    await exec.exec("curl", ["-sSL", "-o", tmp, url]);
-    await exec.exec("sh", [tmp]);
+    await this.execImpl.exec("curl", ["-sSL", "-o", tmp, url]);
+    await this.execImpl.exec("sh", [tmp]);
     fs.rmSync(tmp);
   }
 
   async upgrade(): Promise<number> {
     // Avoid this.exec because we don't need/want globalArgs
-    return await exec.exec("stack", ["upgrade"]);
+    return await this.execImpl.exec("stack", ["upgrade"]);
   }
 
   async setup(args: string[]): Promise<number> {
@@ -139,6 +141,10 @@ export class StackCLI {
   }
 
   private async exec(args: string[], options?: ExecOptions): Promise<number> {
-    return await exec.exec("stack", this.globalArgs.concat(args), options);
+    return await this.execImpl.exec(
+      "stack",
+      this.globalArgs.concat(args),
+      options,
+    );
   }
 }

src/with-cache.test.ts

@@ -1,12 +1,19 @@
 import * as core from "@actions/core";
-import * as cache from "@actions/cache";
 import { jest } from "@jest/globals";
 
 import { getCacheKeys } from "./get-cache-keys.js";
-import { DEFAULT_CACHE_OPTIONS, withCache } from "./with-cache.js";
+import {
+  CacheDelegate,
+  DEFAULT_CACHE_OPTIONS,
+  withCache,
+} from "./with-cache.js";
+
+const cache: CacheDelegate = {
+  restoreCache: jest.fn(() => Promise.resolve("")),
+  saveCache: jest.fn(() => Promise.resolve(0)),
+};
 
 const restoreCacheMock = jest.spyOn(cache, "restoreCache");
-jest.spyOn(cache, "saveCache");
 jest.spyOn(core, "info");
 
 async function testFunction(): Promise<number> {
@@ -43,6 +50,7 @@ test("withCache skips on primary-key hit", async () => {
     cacheKeys,
     testFunction,
     DEFAULT_CACHE_OPTIONS,
+    cache,
   );
 
   expect(result).toBeUndefined();
@@ -64,6 +72,7 @@ test("withCache acts and saves if no primary-key hit", async () => {
     cacheKeys,
     testFunction,
     DEFAULT_CACHE_OPTIONS,
+    cache,
   );
 
   expect(result).toEqual(42);
@@ -83,10 +92,16 @@ test("withCache can be configured to act and save anyway", async () => {
   const cacheKeys = getCacheKeys(["a-b", "c", "d"]);
   restoreCacheMock.mockImplementation(simulateCacheHit);
 
-  const result = await withCache(cachePaths, cacheKeys, testFunction, {
-    ...DEFAULT_CACHE_OPTIONS,
-    skipOnHit: false,
-  });
+  const result = await withCache(
+    cachePaths,
+    cacheKeys,
+    testFunction,
+    {
+      ...DEFAULT_CACHE_OPTIONS,
+      skipOnHit: false,
+    },
+    cache,
+  );
 
   expect(result).toEqual(42);
   expect(cache.restoreCache).toHaveBeenCalledWith(
@@ -110,6 +125,7 @@ test("withCache does not save on error", async () => {
       cacheKeys,
       testFunctionThrows,
       DEFAULT_CACHE_OPTIONS,
+      cache,
     );
   }).rejects.toThrow();
 
@@ -129,10 +145,16 @@ test("withCache can be configured to save on error", async () => {
   restoreCacheMock.mockImplementation(simulateCacheMiss);
 
   await expect(async () => {
-    await withCache(cachePaths, cacheKeys, testFunctionThrows, {
-      ...DEFAULT_CACHE_OPTIONS,
-      saveOnError: true,
-    });
+    await withCache(
+      cachePaths,
+      cacheKeys,
+      testFunctionThrows,
+      {
+        ...DEFAULT_CACHE_OPTIONS,
+        saveOnError: true,
+      },
+      cache,
+    );
   }).rejects.toThrow();
 
   expect(cache.restoreCache).toHaveBeenCalledWith(

src/with-cache.ts

@@ -1,5 +1,5 @@
 import * as core from "@actions/core";
-import * as cache from "@actions/cache";
+import * as realCache from "@actions/cache";
 import type { CacheKeys } from "./get-cache-keys.js";
 
 export type CacheOptions = {
@@ -12,19 +12,30 @@ export const DEFAULT_CACHE_OPTIONS = {
   saveOnError: false,
 };
 
+export interface CacheDelegate {
+  restoreCache: (
+    paths: string[],
+    primaryKey: string,
+    restoreKeys?: string[],
+  ) => Promise<string>;
+  saveCache: (paths: string[], key: string) => Promise<number>;
+}
+
 export async function withCache<T>(
   paths: string[],
   keys: CacheKeys,
   fn: () => Promise<T>,
   options: CacheOptions = DEFAULT_CACHE_OPTIONS,
+  cache?: CacheDelegate,
 ): Promise<T | undefined> {
+  const cacheImpl = cache ?? realCache;
   const { skipOnHit, saveOnError } = options;
 
   core.info(`Cached paths:\n - ${paths.join("\n - ")}`);
   core.info(`Cache key: ${keys.primaryKey}`);
   core.info(`Cache restore keys:\n - ${keys.restoreKeys.join("\n - ")}`);
 
-  const restoredKey = await cache.restoreCache(
+  const restoredKey = await cacheImpl.restoreCache(
     paths,
     keys.primaryKey,
     keys.restoreKeys,
@@ -49,11 +60,11 @@ export async function withCache<T>(
     result = await fn();
 
     if (!primaryKeyHit) {
-      await cache.saveCache(paths, keys.primaryKey);
+      await cacheImpl.saveCache(paths, keys.primaryKey);
     }
   } catch (ex) {
     if (saveOnError && !primaryKeyHit) {
-      await cache.saveCache(paths, keys.primaryKey);
+      await cacheImpl.saveCache(paths, keys.primaryKey);
     }
 
     throw ex;