refactor into a generic outputter

src/outputSetter.ts

@@ -0,0 +1,16 @@
+import * as core from "@actions/core";
+
+export interface IOutputSetter {
+    setOutput(key: string, value: string): void;
+    setState(key: string, value: string): void;
+}
+
+export class StateOutputSetter implements IOutputSetter {
+    setOutput = core.setOutput;
+    setState = core.saveState;
+}
+
+export class NonStateOuputSetter implements IOutputSetter {
+    setOutput = core.setOutput;
+    setState = core.setOutput;
+}

src/restore.ts

@@ -1,22 +1,8 @@
-import * as core from "@actions/core";
+import { StateOutputSetter } from "./outputSetter";
-
-import { Inputs } from "./constants";
 import run from "./restoreImpl";
-import * as utils from "./utils/actionUtils";
 
 async function restore(): Promise<void> {
-    const cacheKey = await run();
+    await run(new StateOutputSetter());
-    if (cacheKey) {
-        // Store the matched cache key in states
-        utils.setCacheState(cacheKey);
-
-        const isExactKeyMatch = utils.isExactKeyMatch(
-            core.getInput(Inputs.Key, { required: true }),
-            cacheKey
-        );
-        utils.setCacheHitOutput(isExactKeyMatch);
-        core.info(`Cache restored from key: ${cacheKey}`);
-    }
 }
 
 export default restore;

src/restoreImpl.ts

@@ -1,10 +1,11 @@
 import * as cache from "@actions/cache";
 import * as core from "@actions/core";
 
-import { Events, Inputs, State } from "./constants";
+import { Events, Inputs, Outputs, State } from "./constants";
+import { IOutputSetter } from "./outputSetter";
 import * as utils from "./utils/actionUtils";
 
-async function run(): Promise<string | undefined> {
+async function run(outputter: IOutputSetter): Promise<string | undefined> {
     try {
         if (!utils.isCacheFeatureAvailable()) {
             utils.setCacheHitOutput(false);
@@ -22,7 +23,7 @@ async function run(): Promise<string | undefined> {
         }
 
         const primaryKey = core.getInput(Inputs.Key, { required: true });
-        core.saveState(State.CachePrimaryKey, primaryKey);
+        outputter.setState(State.CachePrimaryKey, primaryKey);
 
         const restoreKeys = utils.getInputAsArray(Inputs.RestoreKeys);
         const cachePaths = utils.getInputAsArray(Inputs.Path, {
@@ -46,6 +47,18 @@ async function run(): Promise<string | undefined> {
             return;
         }
 
+        // Store the matched cache key in states
+        //utils.setCacheState(cacheKey);
+        outputter.setState(State.CacheMatchedKey, cacheKey);
+
+        const isExactKeyMatch = utils.isExactKeyMatch(
+            core.getInput(Inputs.Key, { required: true }),
+            cacheKey
+        );
+        //utils.setCacheHitOutput(isExactKeyMatch);
+        outputter.setOutput(Outputs.CacheHit, isExactKeyMatch.toString());
+        core.info(`Cache restored from key: ${cacheKey}`);
+
         return cacheKey;
     } catch (error: unknown) {
         core.setFailed((error as Error).message);

src/restoreOnly.ts

@@ -1,17 +1,8 @@
-import * as core from "@actions/core";
+import { NonStateOuputSetter } from "./outputSetter";
-
-import { Outputs } from "./constants";
 import run from "./restoreImpl";
-import * as utils from "./utils/actionUtils";
 
 async function restoreOnly(): Promise<void> {
-    const cacheKey = await run();
+    await run(new NonStateOuputSetter());
-    if (cacheKey) {
-        // Store the matched cache key in output
-        core.setOutput(Outputs.Key, utils.getCacheState());
-
-        core.info(`Cache restored from key: ${cacheKey}`);
-    }
 }
 
 export default restoreOnly;