v1.0.1 release binaries

.eslintrc.json

@@ -1,23 +0,0 @@
-{
-  "env": { "node": true, "jest": true },
-  "parser": "@typescript-eslint/parser",
-  "parserOptions": { "ecmaVersion": 2020, "sourceType": "module" },
-  "extends": [
-    "eslint:recommended",
-    "plugin:@typescript-eslint/eslint-recommended",
-    "plugin:@typescript-eslint/recommended",
-    "plugin:import/errors",
-    "plugin:import/warnings",
-    "plugin:import/typescript",
-    "plugin:prettier/recommended",
-    "prettier/@typescript-eslint"
-  ],
-  "plugins": ["@typescript-eslint", "simple-import-sort", "jest"],
-  "rules": {
-    "import/first": "error",
-    "import/newline-after-import": "error",
-    "import/no-duplicates": "error",
-    "simple-import-sort/sort": "error",
-    "sort-imports": "off"
-  }
-}

.github/workflows/codeql.yml

@@ -1,35 +0,0 @@
-name: "Code Scanning - Action"
-
-on:
-  push:
-  schedule:
-    - cron: '0 0 * * 0'
-
-jobs:
-  CodeQL-Build:
-
-    strategy:
-      fail-fast: false
-
-
-    # CodeQL runs on ubuntu-latest, windows-latest, and macos-latest
-    runs-on: ubuntu-latest
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v2
-
-    # Initializes the CodeQL tools for scanning.
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v1
-      # Override language selection by uncommenting this and choosing your languages
-      # with:
-      #   languages: go, javascript, csharp, python, cpp, java
-
-    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
-    # If this step fails, then you should remove it and run the build manually (see below).
-    - name: Autobuild
-      uses: github/codeql-action/autobuild@v1
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v1

.github/workflows/workflow.yml

@@ -1,11 +1,6 @@
 name: Tests
-
 on:
   pull_request:
-    branches:
-      - master
-    paths-ignore:
-      - '**.md'
   push:
     branches:
       - master
@@ -13,129 +8,24 @@ on:
       - '**.md'
 
 jobs:
-  # Build and unit test
+  test:
-  build:
+    name: Test on ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-latest, windows-latest, macOS-latest]
-      fail-fast: false
     runs-on: ${{ matrix.os }}
+    
     steps:
-    - name: Checkout
+    - uses: actions/checkout@v1
-      uses: actions/checkout@v2
+      
-    - name: Setup Node.js
+    - uses: actions/setup-node@v1
-      uses: actions/setup-node@v1
       with:
         node-version: '12.x'
-    - name: Determine npm cache directory
+
-      id: npm-cache
-      run: |
-        echo "::set-output name=dir::$(npm config get cache)"
-    - name: Restore npm cache
-      uses: actions/cache@v1
-      with:
-        path: ${{ steps.npm-cache.outputs.dir }}
-        key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
-        restore-keys: |
-          ${{ runner.os }}-node-
     - run: npm ci
+
     - name: Prettier Format Check
       run: npm run format-check
-    - name: ESLint Check
+
-      run: npm run lint
     - name: Build & Test
       run: npm run test
-
-  # End to end save and restore
-  test-save:
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macOS-latest]
-      fail-fast: false
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-    - name: Generate files in working directory
-      shell: bash
-      run: __tests__/create-cache-files.sh ${{ runner.os }} test-cache
-    - name: Generate files outside working directory
-      shell: bash
-      run: __tests__/create-cache-files.sh ${{ runner.os }} ~/test-cache
-    - name: Save cache
-      uses: ./
-      with:
-        key: test-${{ runner.os }}-${{ github.run_id }}
-        path: |
-          test-cache
-          ~/test-cache
-  test-restore:
-    needs: test-save
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macOS-latest]
-      fail-fast: false
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-    - name: Restore cache
-      uses: ./
-      with:
-        key: test-${{ runner.os }}-${{ github.run_id }}
-        path: |
-          test-cache
-          ~/test-cache
-    - name: Verify cache files in working directory
-      shell: bash
-      run: __tests__/verify-cache-files.sh ${{ runner.os }} test-cache
-    - name: Verify cache files outside working directory
-      shell: bash
-      run: __tests__/verify-cache-files.sh ${{ runner.os }} ~/test-cache
-
-  # End to end with proxy
-  test-proxy-save:
-    runs-on: ubuntu-latest
-    container:
-      image: ubuntu:latest
-      options: --dns 127.0.0.1
-    services:
-      squid-proxy:
-        image: datadog/squid:latest
-        ports:
-          - 3128:3128
-    env:
-      https_proxy: http://squid-proxy:3128
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-    - name: Generate files
-      run: __tests__/create-cache-files.sh proxy test-cache
-    - name: Save cache
-      uses: ./
-      with:
-        key: test-proxy-${{ github.run_id }}
-        path: test-cache
-  test-proxy-restore:
-    needs: test-proxy-save
-    runs-on: ubuntu-latest
-    container:
-      image: ubuntu:latest
-      options: --dns 127.0.0.1
-    services:
-      squid-proxy:
-        image: datadog/squid:latest
-        ports:
-          - 3128:3128
-    env:
-      https_proxy: http://squid-proxy:3128
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-    - name: Restore cache
-      uses: ./
-      with:
-        key: test-proxy-${{ github.run_id }}
-        path: test-cache
-    - name: Verify cache
-      run: __tests__/verify-cache-files.sh proxy test-cache

.gitignore

@@ -1,5 +1,8 @@
 __tests__/runner/*
 
+# comment out in distribution branches
+dist/
+
 node_modules/
 lib/
 
@@ -91,6 +94,3 @@ typings/
 
 # DynamoDB Local files
 .dynamodb/
-
-# Text editor files
-.vscode/

README.md

@@ -1,8 +1,8 @@
 # cache
 
-This action allows caching dependencies and build outputs to improve workflow execution time.
+This GitHub Action allows caching dependencies and build outputs to improve workflow execution time.
 
-<a href="https://github.com/actions/cache/actions?query=workflow%3ATests"><img alt="GitHub Actions status" src="https://github.com/actions/cache/workflows/Tests/badge.svg?branch=master&event=push"></a>
+<a href="https://github.com/actions/cache"><img alt="GitHub Actions status" src="https://github.com/actions/cache/workflows/Tests/badge.svg?branch=master&event=push"></a>
 
 ## Documentation
 
@@ -28,7 +28,7 @@ Create a workflow `.yml` file in your repositories `.github/workflows` directory
 ### Example workflow
 
 ```yaml
-name: Caching Primes
+name: Example Caching with npm
 
 on: push
 
@@ -37,52 +37,33 @@ jobs:
     runs-on: ubuntu-latest
     
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v1
 
-    - name: Cache Primes
+    - name: Cache node modules
-      id: cache-primes
       uses: actions/cache@v1
       with:
-        path: prime-numbers
+        path: node_modules
-        key: ${{ runner.os }}-primes
+        key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
+        restore-keys: |
+          ${{ runner.os }}-node-
 
-    - name: Generate Prime Numbers
+    - name: Install Dependencies
-      if: steps.cache-primes.outputs.cache-hit != 'true'
+      run: npm install
-      run: /generate-primes.sh -d prime-numbers
     
-    - name: Use Prime Numbers
+    - name: Build
-      run: /primes.sh -d prime-numbers
+      run: npm run build
+
+    - name: Test
+      run: npm run test
 ```
 
-## Implementation Examples
+## Ecosystem Examples
 
-Every programming language and framework has its own way of caching.
+See [Examples](examples.md)
-
-See [Examples](examples.md) for a list of `actions/cache` implementations for use with:
-
-- [C# - Nuget](./examples.md#c---nuget)
-- [Elixir - Mix](./examples.md#elixir---mix)
-- [Go - Modules](./examples.md#go---modules)
-- [Haskell - Cabal](./examples.md#haskell---cabal)
-- [Java - Gradle](./examples.md#java---gradle)
-- [Java - Maven](./examples.md#java---maven)
-- [Node - npm](./examples.md#node---npm)
-- [Node - Lerna](./examples.md#node---lerna)
-- [Node - Yarn](./examples.md#node---yarn)
-- [OCaml/Reason - esy](./examples.md##ocamlreason---esy)
-- [PHP - Composer](./examples.md#php---composer)
-- [Python - pip](./examples.md#python---pip)
-- [R - renv](./examples.md#r---renv)
-- [Ruby - Bundler](./examples.md#ruby---bundler)
-- [Rust - Cargo](./examples.md#rust---cargo)
-- [Scala - SBT](./examples.md#scala---sbt)
-- [Swift, Objective-C - Carthage](./examples.md#swift-objective-c---carthage)
-- [Swift, Objective-C - CocoaPods](./examples.md#swift-objective-c---cocoapods)
-- [Swift - Swift Package Manager](./examples.md#swift---swift-package-manager)
 
 ## Cache Limits
 
-A repository can have up to 5GB of caches. Once the 5GB limit is reached, older caches will be evicted based on when the cache was last accessed.  Caches that are not accessed within the last week will also be evicted.
+Individual caches are limited to 400MB and a repository can have up to 2GB of caches. Once the 2GB limit is reached, older caches will be evicted based on when the cache was last accessed.  Caches that are not accessed within the last week will also be evicted.
 
 ## Skipping steps based on cache-hit
 
@@ -91,13 +72,13 @@ Using the `cache-hit` output, subsequent steps (such as install or build) can be
 Example:
 ```yaml
 steps:
-  - uses: actions/checkout@v2
+  - uses: actions/checkout@v1
 
   - uses: actions/cache@v1
     id: cache
     with:
       path: path/to/dependencies
-      key: ${{ runner.os }}-${{ hashFiles('**/lockfiles') }}
+      key: ${{ runner.os }}-${{ hashFiles('**/lockfiles')}}
   
   - name: Install Dependencies
     if: steps.cache.outputs.cache-hit != 'true'

__tests__/__fixtures__/helloWorld.txt

@@ -1 +0,0 @@
-hello world

__tests__/actionUtils.test.ts

@@ -1,357 +0,0 @@
-import * as core from "@actions/core";
-import * as io from "@actions/io";
-import { promises as fs } from "fs";
-import * as os from "os";
-import * as path from "path";
-
-import { Events, Outputs, State } from "../src/constants";
-import { ArtifactCacheEntry } from "../src/contracts";
-import * as actionUtils from "../src/utils/actionUtils";
-
-import uuid = require("uuid");
-
-jest.mock("@actions/core");
-jest.mock("os");
-
-function getTempDir(): string {
-    return path.join(__dirname, "_temp", "actionUtils");
-}
-
-afterEach(() => {
-    delete process.env[Events.Key];
-});
-
-afterAll(async () => {
-    delete process.env["GITHUB_WORKSPACE"];
-    await io.rmRF(getTempDir());
-});
-
-test("getArchiveFileSize returns file size", () => {
-    const filePath = path.join(__dirname, "__fixtures__", "helloWorld.txt");
-
-    const size = actionUtils.getArchiveFileSize(filePath);
-
-    expect(size).toBe(11);
-});
-
-test("isExactKeyMatch with undefined cache entry returns false", () => {
-    const key = "linux-rust";
-    const cacheEntry = undefined;
-
-    expect(actionUtils.isExactKeyMatch(key, cacheEntry)).toBe(false);
-});
-
-test("isExactKeyMatch with empty cache entry returns false", () => {
-    const key = "linux-rust";
-    const cacheEntry: ArtifactCacheEntry = {};
-
-    expect(actionUtils.isExactKeyMatch(key, cacheEntry)).toBe(false);
-});
-
-test("isExactKeyMatch with different keys returns false", () => {
-    const key = "linux-rust";
-    const cacheEntry: ArtifactCacheEntry = {
-        cacheKey: "linux-"
-    };
-
-    expect(actionUtils.isExactKeyMatch(key, cacheEntry)).toBe(false);
-});
-
-test("isExactKeyMatch with different key accents returns false", () => {
-    const key = "linux-áccent";
-    const cacheEntry: ArtifactCacheEntry = {
-        cacheKey: "linux-accent"
-    };
-
-    expect(actionUtils.isExactKeyMatch(key, cacheEntry)).toBe(false);
-});
-
-test("isExactKeyMatch with same key returns true", () => {
-    const key = "linux-rust";
-    const cacheEntry: ArtifactCacheEntry = {
-        cacheKey: "linux-rust"
-    };
-
-    expect(actionUtils.isExactKeyMatch(key, cacheEntry)).toBe(true);
-});
-
-test("isExactKeyMatch with same key and different casing returns true", () => {
-    const key = "linux-rust";
-    const cacheEntry: ArtifactCacheEntry = {
-        cacheKey: "LINUX-RUST"
-    };
-
-    expect(actionUtils.isExactKeyMatch(key, cacheEntry)).toBe(true);
-});
-
-test("setOutputAndState with undefined entry to set cache-hit output", () => {
-    const key = "linux-rust";
-    const cacheEntry = undefined;
-
-    const setOutputMock = jest.spyOn(core, "setOutput");
-    const saveStateMock = jest.spyOn(core, "saveState");
-
-    actionUtils.setOutputAndState(key, cacheEntry);
-
-    expect(setOutputMock).toHaveBeenCalledWith(Outputs.CacheHit, "false");
-    expect(setOutputMock).toHaveBeenCalledTimes(1);
-
-    expect(saveStateMock).toHaveBeenCalledTimes(0);
-});
-
-test("setOutputAndState with exact match to set cache-hit output and state", () => {
-    const key = "linux-rust";
-    const cacheEntry: ArtifactCacheEntry = {
-        cacheKey: "linux-rust"
-    };
-
-    const setOutputMock = jest.spyOn(core, "setOutput");
-    const saveStateMock = jest.spyOn(core, "saveState");
-
-    actionUtils.setOutputAndState(key, cacheEntry);
-
-    expect(setOutputMock).toHaveBeenCalledWith(Outputs.CacheHit, "true");
-    expect(setOutputMock).toHaveBeenCalledTimes(1);
-
-    expect(saveStateMock).toHaveBeenCalledWith(
-        State.CacheResult,
-        JSON.stringify(cacheEntry)
-    );
-    expect(saveStateMock).toHaveBeenCalledTimes(1);
-});
-
-test("setOutputAndState with no exact match to set cache-hit output and state", () => {
-    const key = "linux-rust";
-    const cacheEntry: ArtifactCacheEntry = {
-        cacheKey: "linux-rust-bb828da54c148048dd17899ba9fda624811cfb43"
-    };
-
-    const setOutputMock = jest.spyOn(core, "setOutput");
-    const saveStateMock = jest.spyOn(core, "saveState");
-
-    actionUtils.setOutputAndState(key, cacheEntry);
-
-    expect(setOutputMock).toHaveBeenCalledWith(Outputs.CacheHit, "false");
-    expect(setOutputMock).toHaveBeenCalledTimes(1);
-
-    expect(saveStateMock).toHaveBeenCalledWith(
-        State.CacheResult,
-        JSON.stringify(cacheEntry)
-    );
-    expect(saveStateMock).toHaveBeenCalledTimes(1);
-});
-
-test("getCacheState with no state returns undefined", () => {
-    const getStateMock = jest.spyOn(core, "getState");
-    getStateMock.mockImplementation(() => {
-        return "";
-    });
-
-    const state = actionUtils.getCacheState();
-
-    expect(state).toBe(undefined);
-
-    expect(getStateMock).toHaveBeenCalledWith(State.CacheResult);
-    expect(getStateMock).toHaveBeenCalledTimes(1);
-});
-
-test("getCacheState with valid state", () => {
-    const cacheEntry: ArtifactCacheEntry = {
-        cacheKey: "Linux-node-bb828da54c148048dd17899ba9fda624811cfb43",
-        scope: "refs/heads/master",
-        creationTime: "2019-11-13T19:18:02+00:00",
-        archiveLocation: "www.actionscache.test/download"
-    };
-    const getStateMock = jest.spyOn(core, "getState");
-    getStateMock.mockImplementation(() => {
-        return JSON.stringify(cacheEntry);
-    });
-
-    const state = actionUtils.getCacheState();
-
-    expect(state).toEqual(cacheEntry);
-
-    expect(getStateMock).toHaveBeenCalledWith(State.CacheResult);
-    expect(getStateMock).toHaveBeenCalledTimes(1);
-});
-
-test("logWarning logs a message with a warning prefix", () => {
-    const message = "A warning occurred.";
-
-    const infoMock = jest.spyOn(core, "info");
-
-    actionUtils.logWarning(message);
-
-    expect(infoMock).toHaveBeenCalledWith(`[warning]${message}`);
-});
-
-test("isValidEvent returns false for unknown event", () => {
-    const event = "foo";
-    process.env[Events.Key] = event;
-
-    const isValidEvent = actionUtils.isValidEvent();
-
-    expect(isValidEvent).toBe(false);
-});
-
-test("resolvePaths with no ~ in path", async () => {
-    const filePath = ".cache";
-
-    // Create the following layout:
-    //   cwd
-    //   cwd/.cache
-    //   cwd/.cache/file.txt
-
-    const root = path.join(getTempDir(), "no-tilde");
-    // tarball entries will be relative to workspace
-    process.env["GITHUB_WORKSPACE"] = root;
-
-    await fs.mkdir(root, { recursive: true });
-    const cache = path.join(root, ".cache");
-    await fs.mkdir(cache, { recursive: true });
-    await fs.writeFile(path.join(cache, "file.txt"), "cached");
-
-    const originalCwd = process.cwd();
-
-    try {
-        process.chdir(root);
-
-        const resolvedPath = await actionUtils.resolvePaths([filePath]);
-
-        const expectedPath = [filePath];
-        expect(resolvedPath).toStrictEqual(expectedPath);
-    } finally {
-        process.chdir(originalCwd);
-    }
-});
-
-test("resolvePaths with ~ in path", async () => {
-    const cacheDir = uuid();
-    const filePath = `~/${cacheDir}`;
-    // Create the following layout:
-    //   ~/uuid
-    //   ~/uuid/file.txt
-
-    const homedir = jest.requireActual("os").homedir();
-    const homedirMock = jest.spyOn(os, "homedir");
-    homedirMock.mockImplementation(() => {
-        return homedir;
-    });
-
-    const target = path.join(homedir, cacheDir);
-    await fs.mkdir(target, { recursive: true });
-    await fs.writeFile(path.join(target, "file.txt"), "cached");
-
-    const root = getTempDir();
-    process.env["GITHUB_WORKSPACE"] = root;
-
-    try {
-        const resolvedPath = await actionUtils.resolvePaths([filePath]);
-
-        const expectedPath = [path.relative(root, target)];
-        expect(resolvedPath).toStrictEqual(expectedPath);
-    } finally {
-        await io.rmRF(target);
-    }
-});
-
-test("resolvePaths with home not found", async () => {
-    const filePath = "~/.cache/yarn";
-    const homedirMock = jest.spyOn(os, "homedir");
-    homedirMock.mockImplementation(() => {
-        return "";
-    });
-
-    await expect(actionUtils.resolvePaths([filePath])).rejects.toThrow(
-        "Unable to determine HOME directory"
-    );
-});
-
-test("resolvePaths inclusion pattern returns found", async () => {
-    const pattern = "*.ts";
-    // Create the following layout:
-    //   inclusion-patterns
-    //   inclusion-patterns/miss.txt
-    //   inclusion-patterns/test.ts
-
-    const root = path.join(getTempDir(), "inclusion-patterns");
-    // tarball entries will be relative to workspace
-    process.env["GITHUB_WORKSPACE"] = root;
-
-    await fs.mkdir(root, { recursive: true });
-    await fs.writeFile(path.join(root, "miss.txt"), "no match");
-    await fs.writeFile(path.join(root, "test.ts"), "match");
-
-    const originalCwd = process.cwd();
-
-    try {
-        process.chdir(root);
-
-        const resolvedPath = await actionUtils.resolvePaths([pattern]);
-
-        const expectedPath = ["test.ts"];
-        expect(resolvedPath).toStrictEqual(expectedPath);
-    } finally {
-        process.chdir(originalCwd);
-    }
-});
-
-test("resolvePaths exclusion pattern returns not found", async () => {
-    const patterns = ["*.ts", "!test.ts"];
-    // Create the following layout:
-    //   exclusion-patterns
-    //   exclusion-patterns/miss.txt
-    //   exclusion-patterns/test.ts
-
-    const root = path.join(getTempDir(), "exclusion-patterns");
-    // tarball entries will be relative to workspace
-    process.env["GITHUB_WORKSPACE"] = root;
-
-    await fs.mkdir(root, { recursive: true });
-    await fs.writeFile(path.join(root, "miss.txt"), "no match");
-    await fs.writeFile(path.join(root, "test.ts"), "no match");
-
-    const originalCwd = process.cwd();
-
-    try {
-        process.chdir(root);
-
-        const resolvedPath = await actionUtils.resolvePaths(patterns);
-
-        const expectedPath = [];
-        expect(resolvedPath).toStrictEqual(expectedPath);
-    } finally {
-        process.chdir(originalCwd);
-    }
-});
-
-test("isValidEvent returns true for push event", () => {
-    const event = Events.Push;
-    process.env[Events.Key] = event;
-
-    const isValidEvent = actionUtils.isValidEvent();
-
-    expect(isValidEvent).toBe(true);
-});
-
-test("isValidEvent returns true for pull request event", () => {
-    const event = Events.PullRequest;
-    process.env[Events.Key] = event;
-
-    const isValidEvent = actionUtils.isValidEvent();
-
-    expect(isValidEvent).toBe(true);
-});
-
-test("unlinkFile unlinks file", async () => {
-    const testDirectory = await fs.mkdtemp("unlinkFileTest");
-    const testFile = path.join(testDirectory, "test.txt");
-    await fs.writeFile(testFile, "hello world");
-
-    await actionUtils.unlinkFile(testFile);
-
-    // This should throw as testFile should not exist
-    await expect(fs.stat(testFile)).rejects.toThrow();
-
-    await fs.rmdir(testDirectory);
-});

__tests__/cacheHttpsClient.test.ts

@@ -1,177 +0,0 @@
-import { getCacheVersion, retry } from "../src/cacheHttpClient";
-import { CompressionMethod, Inputs } from "../src/constants";
-import * as testUtils from "../src/utils/testUtils";
-
-afterEach(() => {
-    testUtils.clearInputs();
-});
-
-test("getCacheVersion with path input and compression method undefined returns version", async () => {
-    testUtils.setInput(Inputs.Path, "node_modules");
-
-    const result = getCacheVersion();
-
-    expect(result).toEqual(
-        "b3e0c6cb5ecf32614eeb2997d905b9c297046d7cbf69062698f25b14b4cb0985"
-    );
-});
-
-test("getCacheVersion with zstd compression returns version", async () => {
-    testUtils.setInput(Inputs.Path, "node_modules");
-    const result = getCacheVersion(CompressionMethod.Zstd);
-
-    expect(result).toEqual(
-        "273877e14fd65d270b87a198edbfa2db5a43de567c9a548d2a2505b408befe24"
-    );
-});
-
-test("getCacheVersion with gzip compression does not change vesion", async () => {
-    testUtils.setInput(Inputs.Path, "node_modules");
-    const result = getCacheVersion(CompressionMethod.Gzip);
-
-    expect(result).toEqual(
-        "b3e0c6cb5ecf32614eeb2997d905b9c297046d7cbf69062698f25b14b4cb0985"
-    );
-});
-
-test("getCacheVersion with no input throws", async () => {
-    expect(() => getCacheVersion()).toThrow();
-});
-
-interface TestResponse {
-    statusCode: number;
-    result: string | null;
-}
-
-function handleResponse(
-    response: TestResponse | undefined
-): Promise<TestResponse> {
-    if (!response) {
-        fail("Retry method called too many times");
-    }
-
-    if (response.statusCode === 999) {
-        throw Error("Test Error");
-    } else {
-        return Promise.resolve(response);
-    }
-}
-
-async function testRetryExpectingResult(
-    responses: Array<TestResponse>,
-    expectedResult: string | null
-): Promise<void> {
-    responses = responses.reverse(); // Reverse responses since we pop from end
-
-    const actualResult = await retry(
-        "test",
-        () => handleResponse(responses.pop()),
-        (response: TestResponse) => response.statusCode
-    );
-
-    expect(actualResult.result).toEqual(expectedResult);
-}
-
-async function testRetryExpectingError(
-    responses: Array<TestResponse>
-): Promise<void> {
-    responses = responses.reverse(); // Reverse responses since we pop from end
-
-    expect(
-        retry(
-            "test",
-            () => handleResponse(responses.pop()),
-            (response: TestResponse) => response.statusCode
-        )
-    ).rejects.toBeInstanceOf(Error);
-}
-
-test("retry works on successful response", async () => {
-    await testRetryExpectingResult(
-        [
-            {
-                statusCode: 200,
-                result: "Ok"
-            }
-        ],
-        "Ok"
-    );
-});
-
-test("retry works after retryable status code", async () => {
-    await testRetryExpectingResult(
-        [
-            {
-                statusCode: 503,
-                result: null
-            },
-            {
-                statusCode: 200,
-                result: "Ok"
-            }
-        ],
-        "Ok"
-    );
-});
-
-test("retry fails after exhausting retries", async () => {
-    await testRetryExpectingError([
-        {
-            statusCode: 503,
-            result: null
-        },
-        {
-            statusCode: 503,
-            result: null
-        },
-        {
-            statusCode: 200,
-            result: "Ok"
-        }
-    ]);
-});
-
-test("retry fails after non-retryable status code", async () => {
-    await testRetryExpectingError([
-        {
-            statusCode: 500,
-            result: null
-        },
-        {
-            statusCode: 200,
-            result: "Ok"
-        }
-    ]);
-});
-
-test("retry works after error", async () => {
-    await testRetryExpectingResult(
-        [
-            {
-                statusCode: 999,
-                result: null
-            },
-            {
-                statusCode: 200,
-                result: "Ok"
-            }
-        ],
-        "Ok"
-    );
-});
-
-test("retry returns after client error", async () => {
-    await testRetryExpectingResult(
-        [
-            {
-                statusCode: 400,
-                result: null
-            },
-            {
-                statusCode: 200,
-                result: "Ok"
-            }
-        ],
-        null
-    );
-});

__tests__/create-cache-files.sh

@@ -1,17 +0,0 @@
-#!/bin/sh
-
-# Validate args
-prefix="$1"
-if [ -z "$prefix" ]; then
-  echo "Must supply prefix argument"
-  exit 1
-fi
-
-path="$2"
-if [ -z "$path" ]; then
-  echo "Must supply path argument"
-  exit 1
-fi
-
-mkdir -p $path
-echo "$prefix $GITHUB_RUN_ID" > $path/test-file.txt

__tests__/main.test.ts

@@ -0,0 +1,22 @@
+import * as core from "@actions/core";
+
+import { Inputs } from "../src/constants";
+import run from "../src/restore";
+import * as testUtils from "../src/utils/testUtils";
+
+test("restore with no path", async () => {
+    const failedMock = jest.spyOn(core, "setFailed");
+    await run();
+    expect(failedMock).toHaveBeenCalledWith(
+        "Input required and not supplied: path"
+    );
+});
+
+test("restore with no key", async () => {
+    testUtils.setInput(Inputs.Path, "node_modules");
+    const failedMock = jest.spyOn(core, "setFailed");
+    await run();
+    expect(failedMock).toHaveBeenCalledWith(
+        "Input required and not supplied: key"
+    );
+});

__tests__/restore.test.ts

@@ -1,434 +0,0 @@
-import * as core from "@actions/core";
-import * as path from "path";
-
-import * as cacheHttpClient from "../src/cacheHttpClient";
-import {
-    CacheFilename,
-    CompressionMethod,
-    Events,
-    Inputs
-} from "../src/constants";
-import { ArtifactCacheEntry } from "../src/contracts";
-import run from "../src/restore";
-import * as tar from "../src/tar";
-import * as actionUtils from "../src/utils/actionUtils";
-import * as testUtils from "../src/utils/testUtils";
-
-jest.mock("../src/cacheHttpClient");
-jest.mock("../src/tar");
-jest.mock("../src/utils/actionUtils");
-
-beforeAll(() => {
-    jest.spyOn(actionUtils, "isExactKeyMatch").mockImplementation(
-        (key, cacheResult) => {
-            const actualUtils = jest.requireActual("../src/utils/actionUtils");
-            return actualUtils.isExactKeyMatch(key, cacheResult);
-        }
-    );
-
-    jest.spyOn(actionUtils, "isValidEvent").mockImplementation(() => {
-        const actualUtils = jest.requireActual("../src/utils/actionUtils");
-        return actualUtils.isValidEvent();
-    });
-
-    jest.spyOn(actionUtils, "getSupportedEvents").mockImplementation(() => {
-        const actualUtils = jest.requireActual("../src/utils/actionUtils");
-        return actualUtils.getSupportedEvents();
-    });
-
-    jest.spyOn(actionUtils, "getCacheFileName").mockImplementation(cm => {
-        const actualUtils = jest.requireActual("../src/utils/actionUtils");
-        return actualUtils.getCacheFileName(cm);
-    });
-});
-
-beforeEach(() => {
-    process.env[Events.Key] = Events.Push;
-});
-
-afterEach(() => {
-    testUtils.clearInputs();
-    delete process.env[Events.Key];
-});
-
-test("restore with invalid event outputs warning", async () => {
-    const logWarningMock = jest.spyOn(actionUtils, "logWarning");
-    const failedMock = jest.spyOn(core, "setFailed");
-    const invalidEvent = "commit_comment";
-    process.env[Events.Key] = invalidEvent;
-    await run();
-    expect(logWarningMock).toHaveBeenCalledWith(
-        `Event Validation Error: The event type ${invalidEvent} is not supported. Only push, pull_request events are supported at this time.`
-    );
-    expect(failedMock).toHaveBeenCalledTimes(0);
-});
-
-test("restore with no path should fail", async () => {
-    const failedMock = jest.spyOn(core, "setFailed");
-    await run();
-    // this input isn't necessary for restore b/c tarball contains entries relative to workspace
-    expect(failedMock).not.toHaveBeenCalledWith(
-        "Input required and not supplied: path"
-    );
-});
-
-test("restore with no key", async () => {
-    testUtils.setInput(Inputs.Path, "node_modules");
-    const failedMock = jest.spyOn(core, "setFailed");
-    await run();
-    expect(failedMock).toHaveBeenCalledWith(
-        "Input required and not supplied: key"
-    );
-});
-
-test("restore with too many keys should fail", async () => {
-    const key = "node-test";
-    const restoreKeys = [...Array(20).keys()].map(x => x.toString());
-    testUtils.setInputs({
-        path: "node_modules",
-        key,
-        restoreKeys
-    });
-    const failedMock = jest.spyOn(core, "setFailed");
-    await run();
-    expect(failedMock).toHaveBeenCalledWith(
-        `Key Validation Error: Keys are limited to a maximum of 10.`
-    );
-});
-
-test("restore with large key should fail", async () => {
-    const key = "foo".repeat(512); // Over the 512 character limit
-    testUtils.setInputs({
-        path: "node_modules",
-        key
-    });
-    const failedMock = jest.spyOn(core, "setFailed");
-    await run();
-    expect(failedMock).toHaveBeenCalledWith(
-        `Key Validation Error: ${key} cannot be larger than 512 characters.`
-    );
-});
-
-test("restore with invalid key should fail", async () => {
-    const key = "comma,comma";
-    testUtils.setInputs({
-        path: "node_modules",
-        key
-    });
-    const failedMock = jest.spyOn(core, "setFailed");
-    await run();
-    expect(failedMock).toHaveBeenCalledWith(
-        `Key Validation Error: ${key} cannot contain commas.`
-    );
-});
-
-test("restore with no cache found", async () => {
-    const key = "node-test";
-    testUtils.setInputs({
-        path: "node_modules",
-        key
-    });
-
-    const infoMock = jest.spyOn(core, "info");
-    const failedMock = jest.spyOn(core, "setFailed");
-    const stateMock = jest.spyOn(core, "saveState");
-
-    const clientMock = jest.spyOn(cacheHttpClient, "getCacheEntry");
-    clientMock.mockImplementation(() => {
-        return Promise.resolve(null);
-    });
-
-    await run();
-
-    expect(stateMock).toHaveBeenCalledWith("CACHE_KEY", key);
-    expect(failedMock).toHaveBeenCalledTimes(0);
-
-    expect(infoMock).toHaveBeenCalledWith(
-        `Cache not found for input keys: ${key}`
-    );
-});
-
-test("restore with server error should fail", async () => {
-    const key = "node-test";
-    testUtils.setInputs({
-        path: "node_modules",
-        key
-    });
-
-    const logWarningMock = jest.spyOn(actionUtils, "logWarning");
-    const failedMock = jest.spyOn(core, "setFailed");
-    const stateMock = jest.spyOn(core, "saveState");
-
-    const clientMock = jest.spyOn(cacheHttpClient, "getCacheEntry");
-    clientMock.mockImplementation(() => {
-        throw new Error("HTTP Error Occurred");
-    });
-
-    const setCacheHitOutputMock = jest.spyOn(actionUtils, "setCacheHitOutput");
-
-    await run();
-
-    expect(stateMock).toHaveBeenCalledWith("CACHE_KEY", key);
-
-    expect(logWarningMock).toHaveBeenCalledTimes(1);
-    expect(logWarningMock).toHaveBeenCalledWith("HTTP Error Occurred");
-
-    expect(setCacheHitOutputMock).toHaveBeenCalledTimes(1);
-    expect(setCacheHitOutputMock).toHaveBeenCalledWith(false);
-
-    expect(failedMock).toHaveBeenCalledTimes(0);
-});
-
-test("restore with restore keys and no cache found", async () => {
-    const key = "node-test";
-    const restoreKey = "node-";
-    testUtils.setInputs({
-        path: "node_modules",
-        key,
-        restoreKeys: [restoreKey]
-    });
-
-    const infoMock = jest.spyOn(core, "info");
-    const failedMock = jest.spyOn(core, "setFailed");
-    const stateMock = jest.spyOn(core, "saveState");
-
-    const clientMock = jest.spyOn(cacheHttpClient, "getCacheEntry");
-    clientMock.mockImplementation(() => {
-        return Promise.resolve(null);
-    });
-
-    await run();
-
-    expect(stateMock).toHaveBeenCalledWith("CACHE_KEY", key);
-    expect(failedMock).toHaveBeenCalledTimes(0);
-
-    expect(infoMock).toHaveBeenCalledWith(
-        `Cache not found for input keys: ${key}, ${restoreKey}`
-    );
-});
-
-test("restore with gzip compressed cache found", async () => {
-    const key = "node-test";
-    testUtils.setInputs({
-        path: "node_modules",
-        key
-    });
-
-    const infoMock = jest.spyOn(core, "info");
-    const failedMock = jest.spyOn(core, "setFailed");
-    const stateMock = jest.spyOn(core, "saveState");
-
-    const cacheEntry: ArtifactCacheEntry = {
-        cacheKey: key,
-        scope: "refs/heads/master",
-        archiveLocation: "www.actionscache.test/download"
-    };
-    const getCacheMock = jest.spyOn(cacheHttpClient, "getCacheEntry");
-    getCacheMock.mockImplementation(() => {
-        return Promise.resolve(cacheEntry);
-    });
-    const tempPath = "/foo/bar";
-
-    const createTempDirectoryMock = jest.spyOn(
-        actionUtils,
-        "createTempDirectory"
-    );
-    createTempDirectoryMock.mockImplementation(() => {
-        return Promise.resolve(tempPath);
-    });
-
-    const archivePath = path.join(tempPath, CacheFilename.Gzip);
-    const setCacheStateMock = jest.spyOn(actionUtils, "setCacheState");
-    const downloadCacheMock = jest.spyOn(cacheHttpClient, "downloadCache");
-
-    const fileSize = 142;
-    const getArchiveFileSizeMock = jest
-        .spyOn(actionUtils, "getArchiveFileSize")
-        .mockReturnValue(fileSize);
-
-    const extractTarMock = jest.spyOn(tar, "extractTar");
-    const unlinkFileMock = jest.spyOn(actionUtils, "unlinkFile");
-    const setCacheHitOutputMock = jest.spyOn(actionUtils, "setCacheHitOutput");
-
-    const compression = CompressionMethod.Gzip;
-    const getCompressionMock = jest
-        .spyOn(actionUtils, "getCompressionMethod")
-        .mockReturnValue(Promise.resolve(compression));
-
-    await run();
-
-    expect(stateMock).toHaveBeenCalledWith("CACHE_KEY", key);
-    expect(getCacheMock).toHaveBeenCalledWith([key], {
-        compressionMethod: compression
-    });
-    expect(setCacheStateMock).toHaveBeenCalledWith(cacheEntry);
-    expect(createTempDirectoryMock).toHaveBeenCalledTimes(1);
-    expect(downloadCacheMock).toHaveBeenCalledWith(
-        cacheEntry.archiveLocation,
-        archivePath
-    );
-    expect(getArchiveFileSizeMock).toHaveBeenCalledWith(archivePath);
-
-    expect(extractTarMock).toHaveBeenCalledTimes(1);
-    expect(extractTarMock).toHaveBeenCalledWith(archivePath, compression);
-
-    expect(unlinkFileMock).toHaveBeenCalledTimes(1);
-    expect(unlinkFileMock).toHaveBeenCalledWith(archivePath);
-
-    expect(setCacheHitOutputMock).toHaveBeenCalledTimes(1);
-    expect(setCacheHitOutputMock).toHaveBeenCalledWith(true);
-
-    expect(infoMock).toHaveBeenCalledWith(`Cache restored from key: ${key}`);
-    expect(failedMock).toHaveBeenCalledTimes(0);
-    expect(getCompressionMock).toHaveBeenCalledTimes(1);
-});
-
-test("restore with a pull request event and zstd compressed cache found", async () => {
-    const key = "node-test";
-    testUtils.setInputs({
-        path: "node_modules",
-        key
-    });
-
-    process.env[Events.Key] = Events.PullRequest;
-
-    const infoMock = jest.spyOn(core, "info");
-    const failedMock = jest.spyOn(core, "setFailed");
-    const stateMock = jest.spyOn(core, "saveState");
-
-    const cacheEntry: ArtifactCacheEntry = {
-        cacheKey: key,
-        scope: "refs/heads/master",
-        archiveLocation: "www.actionscache.test/download"
-    };
-    const getCacheMock = jest.spyOn(cacheHttpClient, "getCacheEntry");
-    getCacheMock.mockImplementation(() => {
-        return Promise.resolve(cacheEntry);
-    });
-    const tempPath = "/foo/bar";
-
-    const createTempDirectoryMock = jest.spyOn(
-        actionUtils,
-        "createTempDirectory"
-    );
-    createTempDirectoryMock.mockImplementation(() => {
-        return Promise.resolve(tempPath);
-    });
-
-    const archivePath = path.join(tempPath, CacheFilename.Zstd);
-    const setCacheStateMock = jest.spyOn(actionUtils, "setCacheState");
-    const downloadCacheMock = jest.spyOn(cacheHttpClient, "downloadCache");
-
-    const fileSize = 62915000;
-    const getArchiveFileSizeMock = jest
-        .spyOn(actionUtils, "getArchiveFileSize")
-        .mockReturnValue(fileSize);
-
-    const extractTarMock = jest.spyOn(tar, "extractTar");
-    const setCacheHitOutputMock = jest.spyOn(actionUtils, "setCacheHitOutput");
-    const compression = CompressionMethod.Zstd;
-    const getCompressionMock = jest
-        .spyOn(actionUtils, "getCompressionMethod")
-        .mockReturnValue(Promise.resolve(compression));
-
-    await run();
-
-    expect(stateMock).toHaveBeenCalledWith("CACHE_KEY", key);
-    expect(getCacheMock).toHaveBeenCalledWith([key], {
-        compressionMethod: compression
-    });
-    expect(setCacheStateMock).toHaveBeenCalledWith(cacheEntry);
-    expect(createTempDirectoryMock).toHaveBeenCalledTimes(1);
-    expect(downloadCacheMock).toHaveBeenCalledWith(
-        cacheEntry.archiveLocation,
-        archivePath
-    );
-    expect(getArchiveFileSizeMock).toHaveBeenCalledWith(archivePath);
-    expect(infoMock).toHaveBeenCalledWith(`Cache Size: ~60 MB (62915000 B)`);
-
-    expect(extractTarMock).toHaveBeenCalledTimes(1);
-    expect(extractTarMock).toHaveBeenCalledWith(archivePath, compression);
-
-    expect(setCacheHitOutputMock).toHaveBeenCalledTimes(1);
-    expect(setCacheHitOutputMock).toHaveBeenCalledWith(true);
-
-    expect(infoMock).toHaveBeenCalledWith(`Cache restored from key: ${key}`);
-    expect(failedMock).toHaveBeenCalledTimes(0);
-    expect(getCompressionMock).toHaveBeenCalledTimes(1);
-});
-
-test("restore with cache found for restore key", async () => {
-    const key = "node-test";
-    const restoreKey = "node-";
-    testUtils.setInputs({
-        path: "node_modules",
-        key,
-        restoreKeys: [restoreKey]
-    });
-
-    const infoMock = jest.spyOn(core, "info");
-    const failedMock = jest.spyOn(core, "setFailed");
-    const stateMock = jest.spyOn(core, "saveState");
-
-    const cacheEntry: ArtifactCacheEntry = {
-        cacheKey: restoreKey,
-        scope: "refs/heads/master",
-        archiveLocation: "www.actionscache.test/download"
-    };
-    const getCacheMock = jest.spyOn(cacheHttpClient, "getCacheEntry");
-    getCacheMock.mockImplementation(() => {
-        return Promise.resolve(cacheEntry);
-    });
-    const tempPath = "/foo/bar";
-
-    const createTempDirectoryMock = jest.spyOn(
-        actionUtils,
-        "createTempDirectory"
-    );
-    createTempDirectoryMock.mockImplementation(() => {
-        return Promise.resolve(tempPath);
-    });
-
-    const archivePath = path.join(tempPath, CacheFilename.Zstd);
-    const setCacheStateMock = jest.spyOn(actionUtils, "setCacheState");
-    const downloadCacheMock = jest.spyOn(cacheHttpClient, "downloadCache");
-
-    const fileSize = 142;
-    const getArchiveFileSizeMock = jest
-        .spyOn(actionUtils, "getArchiveFileSize")
-        .mockReturnValue(fileSize);
-
-    const extractTarMock = jest.spyOn(tar, "extractTar");
-    const setCacheHitOutputMock = jest.spyOn(actionUtils, "setCacheHitOutput");
-    const compression = CompressionMethod.Zstd;
-    const getCompressionMock = jest
-        .spyOn(actionUtils, "getCompressionMethod")
-        .mockReturnValue(Promise.resolve(compression));
-
-    await run();
-
-    expect(stateMock).toHaveBeenCalledWith("CACHE_KEY", key);
-    expect(getCacheMock).toHaveBeenCalledWith([key, restoreKey], {
-        compressionMethod: compression
-    });
-    expect(setCacheStateMock).toHaveBeenCalledWith(cacheEntry);
-    expect(createTempDirectoryMock).toHaveBeenCalledTimes(1);
-    expect(downloadCacheMock).toHaveBeenCalledWith(
-        cacheEntry.archiveLocation,
-        archivePath
-    );
-    expect(getArchiveFileSizeMock).toHaveBeenCalledWith(archivePath);
-    expect(infoMock).toHaveBeenCalledWith(`Cache Size: ~0 MB (142 B)`);
-
-    expect(extractTarMock).toHaveBeenCalledTimes(1);
-    expect(extractTarMock).toHaveBeenCalledWith(archivePath, compression);
-
-    expect(setCacheHitOutputMock).toHaveBeenCalledTimes(1);
-    expect(setCacheHitOutputMock).toHaveBeenCalledWith(false);
-
-    expect(infoMock).toHaveBeenCalledWith(
-        `Cache restored from key: ${restoreKey}`
-    );
-    expect(failedMock).toHaveBeenCalledTimes(0);
-    expect(getCompressionMock).toHaveBeenCalledTimes(1);
-});

__tests__/save.test.ts

@@ -1,428 +0,0 @@
-import * as core from "@actions/core";
-import * as path from "path";
-
-import * as cacheHttpClient from "../src/cacheHttpClient";
-import {
-    CacheFilename,
-    CompressionMethod,
-    Events,
-    Inputs
-} from "../src/constants";
-import { ArtifactCacheEntry } from "../src/contracts";
-import run from "../src/save";
-import * as tar from "../src/tar";
-import * as actionUtils from "../src/utils/actionUtils";
-import * as testUtils from "../src/utils/testUtils";
-
-jest.mock("@actions/core");
-jest.mock("../src/cacheHttpClient");
-jest.mock("../src/tar");
-jest.mock("../src/utils/actionUtils");
-
-beforeAll(() => {
-    jest.spyOn(core, "getInput").mockImplementation((name, options) => {
-        return jest.requireActual("@actions/core").getInput(name, options);
-    });
-
-    jest.spyOn(actionUtils, "getCacheState").mockImplementation(() => {
-        return jest.requireActual("../src/utils/actionUtils").getCacheState();
-    });
-
-    jest.spyOn(actionUtils, "isExactKeyMatch").mockImplementation(
-        (key, cacheResult) => {
-            return jest
-                .requireActual("../src/utils/actionUtils")
-                .isExactKeyMatch(key, cacheResult);
-        }
-    );
-
-    jest.spyOn(actionUtils, "isValidEvent").mockImplementation(() => {
-        const actualUtils = jest.requireActual("../src/utils/actionUtils");
-        return actualUtils.isValidEvent();
-    });
-
-    jest.spyOn(actionUtils, "getSupportedEvents").mockImplementation(() => {
-        const actualUtils = jest.requireActual("../src/utils/actionUtils");
-        return actualUtils.getSupportedEvents();
-    });
-
-    jest.spyOn(actionUtils, "resolvePaths").mockImplementation(
-        async filePaths => {
-            return filePaths.map(x => path.resolve(x));
-        }
-    );
-
-    jest.spyOn(actionUtils, "createTempDirectory").mockImplementation(() => {
-        return Promise.resolve("/foo/bar");
-    });
-
-    jest.spyOn(actionUtils, "getCacheFileName").mockImplementation(cm => {
-        const actualUtils = jest.requireActual("../src/utils/actionUtils");
-        return actualUtils.getCacheFileName(cm);
-    });
-});
-
-beforeEach(() => {
-    process.env[Events.Key] = Events.Push;
-});
-
-afterEach(() => {
-    testUtils.clearInputs();
-    delete process.env[Events.Key];
-});
-
-test("save with invalid event outputs warning", async () => {
-    const logWarningMock = jest.spyOn(actionUtils, "logWarning");
-    const failedMock = jest.spyOn(core, "setFailed");
-    const invalidEvent = "commit_comment";
-    process.env[Events.Key] = invalidEvent;
-    await run();
-    expect(logWarningMock).toHaveBeenCalledWith(
-        `Event Validation Error: The event type ${invalidEvent} is not supported. Only push, pull_request events are supported at this time.`
-    );
-    expect(failedMock).toHaveBeenCalledTimes(0);
-});
-
-test("save with no primary key in state outputs warning", async () => {
-    const logWarningMock = jest.spyOn(actionUtils, "logWarning");
-    const failedMock = jest.spyOn(core, "setFailed");
-
-    const cacheEntry: ArtifactCacheEntry = {
-        cacheKey: "Linux-node-bb828da54c148048dd17899ba9fda624811cfb43",
-        scope: "refs/heads/master",
-        creationTime: "2019-11-13T19:18:02+00:00",
-        archiveLocation: "www.actionscache.test/download"
-    };
-
-    jest.spyOn(core, "getState")
-        // Cache Entry State
-        .mockImplementationOnce(() => {
-            return JSON.stringify(cacheEntry);
-        })
-        // Cache Key State
-        .mockImplementationOnce(() => {
-            return "";
-        });
-
-    await run();
-
-    expect(logWarningMock).toHaveBeenCalledWith(
-        `Error retrieving key from state.`
-    );
-    expect(logWarningMock).toHaveBeenCalledTimes(1);
-    expect(failedMock).toHaveBeenCalledTimes(0);
-});
-
-test("save with exact match returns early", async () => {
-    const infoMock = jest.spyOn(core, "info");
-    const failedMock = jest.spyOn(core, "setFailed");
-
-    const primaryKey = "Linux-node-bb828da54c148048dd17899ba9fda624811cfb43";
-    const cacheEntry: ArtifactCacheEntry = {
-        cacheKey: primaryKey,
-        scope: "refs/heads/master",
-        creationTime: "2019-11-13T19:18:02+00:00",
-        archiveLocation: "www.actionscache.test/download"
-    };
-
-    jest.spyOn(core, "getState")
-        // Cache Entry State
-        .mockImplementationOnce(() => {
-            return JSON.stringify(cacheEntry);
-        })
-        // Cache Key State
-        .mockImplementationOnce(() => {
-            return primaryKey;
-        });
-
-    const createTarMock = jest.spyOn(tar, "createTar");
-
-    await run();
-
-    expect(infoMock).toHaveBeenCalledWith(
-        `Cache hit occurred on the primary key ${primaryKey}, not saving cache.`
-    );
-
-    expect(createTarMock).toHaveBeenCalledTimes(0);
-
-    expect(failedMock).toHaveBeenCalledTimes(0);
-});
-
-test("save with missing input outputs warning", async () => {
-    const logWarningMock = jest.spyOn(actionUtils, "logWarning");
-    const failedMock = jest.spyOn(core, "setFailed");
-
-    const primaryKey = "Linux-node-bb828da54c148048dd17899ba9fda624811cfb43";
-    const cacheEntry: ArtifactCacheEntry = {
-        cacheKey: "Linux-node-",
-        scope: "refs/heads/master",
-        creationTime: "2019-11-13T19:18:02+00:00",
-        archiveLocation: "www.actionscache.test/download"
-    };
-
-    jest.spyOn(core, "getState")
-        // Cache Entry State
-        .mockImplementationOnce(() => {
-            return JSON.stringify(cacheEntry);
-        })
-        // Cache Key State
-        .mockImplementationOnce(() => {
-            return primaryKey;
-        });
-
-    await run();
-
-    expect(logWarningMock).toHaveBeenCalledWith(
-        "Input required and not supplied: path"
-    );
-    expect(logWarningMock).toHaveBeenCalledTimes(1);
-    expect(failedMock).toHaveBeenCalledTimes(0);
-});
-
-test("save with large cache outputs warning", async () => {
-    const logWarningMock = jest.spyOn(actionUtils, "logWarning");
-    const failedMock = jest.spyOn(core, "setFailed");
-
-    const primaryKey = "Linux-node-bb828da54c148048dd17899ba9fda624811cfb43";
-    const cacheEntry: ArtifactCacheEntry = {
-        cacheKey: "Linux-node-",
-        scope: "refs/heads/master",
-        creationTime: "2019-11-13T19:18:02+00:00",
-        archiveLocation: "www.actionscache.test/download"
-    };
-
-    jest.spyOn(core, "getState")
-        // Cache Entry State
-        .mockImplementationOnce(() => {
-            return JSON.stringify(cacheEntry);
-        })
-        // Cache Key State
-        .mockImplementationOnce(() => {
-            return primaryKey;
-        });
-
-    const inputPath = "node_modules";
-    const cachePaths = [path.resolve(inputPath)];
-    testUtils.setInput(Inputs.Path, inputPath);
-
-    const createTarMock = jest.spyOn(tar, "createTar");
-
-    const cacheSize = 6 * 1024 * 1024 * 1024; //~6GB, over the 5GB limit
-    jest.spyOn(actionUtils, "getArchiveFileSize").mockImplementationOnce(() => {
-        return cacheSize;
-    });
-    const compression = CompressionMethod.Gzip;
-    const getCompressionMock = jest
-        .spyOn(actionUtils, "getCompressionMethod")
-        .mockReturnValue(Promise.resolve(compression));
-
-    await run();
-
-    const archiveFolder = "/foo/bar";
-
-    expect(createTarMock).toHaveBeenCalledTimes(1);
-    expect(createTarMock).toHaveBeenCalledWith(
-        archiveFolder,
-        cachePaths,
-        compression
-    );
-    expect(logWarningMock).toHaveBeenCalledTimes(1);
-    expect(logWarningMock).toHaveBeenCalledWith(
-        "Cache size of ~6144 MB (6442450944 B) is over the 5GB limit, not saving cache."
-    );
-    expect(failedMock).toHaveBeenCalledTimes(0);
-    expect(getCompressionMock).toHaveBeenCalledTimes(1);
-});
-
-test("save with reserve cache failure outputs warning", async () => {
-    const infoMock = jest.spyOn(core, "info");
-    const logWarningMock = jest.spyOn(actionUtils, "logWarning");
-    const failedMock = jest.spyOn(core, "setFailed");
-
-    const primaryKey = "Linux-node-bb828da54c148048dd17899ba9fda624811cfb43";
-    const cacheEntry: ArtifactCacheEntry = {
-        cacheKey: "Linux-node-",
-        scope: "refs/heads/master",
-        creationTime: "2019-11-13T19:18:02+00:00",
-        archiveLocation: "www.actionscache.test/download"
-    };
-
-    jest.spyOn(core, "getState")
-        // Cache Entry State
-        .mockImplementationOnce(() => {
-            return JSON.stringify(cacheEntry);
-        })
-        // Cache Key State
-        .mockImplementationOnce(() => {
-            return primaryKey;
-        });
-
-    const inputPath = "node_modules";
-    testUtils.setInput(Inputs.Path, inputPath);
-
-    const reserveCacheMock = jest
-        .spyOn(cacheHttpClient, "reserveCache")
-        .mockImplementationOnce(() => {
-            return Promise.resolve(-1);
-        });
-
-    const createTarMock = jest.spyOn(tar, "createTar");
-    const saveCacheMock = jest.spyOn(cacheHttpClient, "saveCache");
-    const compression = CompressionMethod.Zstd;
-    const getCompressionMock = jest
-        .spyOn(actionUtils, "getCompressionMethod")
-        .mockReturnValue(Promise.resolve(compression));
-
-    await run();
-
-    expect(reserveCacheMock).toHaveBeenCalledTimes(1);
-    expect(reserveCacheMock).toHaveBeenCalledWith(primaryKey, {
-        compressionMethod: compression
-    });
-
-    expect(infoMock).toHaveBeenCalledWith(
-        `Unable to reserve cache with key ${primaryKey}, another job may be creating this cache.`
-    );
-
-    expect(createTarMock).toHaveBeenCalledTimes(0);
-    expect(saveCacheMock).toHaveBeenCalledTimes(0);
-    expect(logWarningMock).toHaveBeenCalledTimes(0);
-    expect(failedMock).toHaveBeenCalledTimes(0);
-    expect(getCompressionMock).toHaveBeenCalledTimes(1);
-});
-
-test("save with server error outputs warning", async () => {
-    const logWarningMock = jest.spyOn(actionUtils, "logWarning");
-    const failedMock = jest.spyOn(core, "setFailed");
-
-    const primaryKey = "Linux-node-bb828da54c148048dd17899ba9fda624811cfb43";
-    const cacheEntry: ArtifactCacheEntry = {
-        cacheKey: "Linux-node-",
-        scope: "refs/heads/master",
-        creationTime: "2019-11-13T19:18:02+00:00",
-        archiveLocation: "www.actionscache.test/download"
-    };
-
-    jest.spyOn(core, "getState")
-        // Cache Entry State
-        .mockImplementationOnce(() => {
-            return JSON.stringify(cacheEntry);
-        })
-        // Cache Key State
-        .mockImplementationOnce(() => {
-            return primaryKey;
-        });
-
-    const inputPath = "node_modules";
-    const cachePaths = [path.resolve(inputPath)];
-    testUtils.setInput(Inputs.Path, inputPath);
-
-    const cacheId = 4;
-    const reserveCacheMock = jest
-        .spyOn(cacheHttpClient, "reserveCache")
-        .mockImplementationOnce(() => {
-            return Promise.resolve(cacheId);
-        });
-
-    const createTarMock = jest.spyOn(tar, "createTar");
-
-    const saveCacheMock = jest
-        .spyOn(cacheHttpClient, "saveCache")
-        .mockImplementationOnce(() => {
-            throw new Error("HTTP Error Occurred");
-        });
-    const compression = CompressionMethod.Zstd;
-    const getCompressionMock = jest
-        .spyOn(actionUtils, "getCompressionMethod")
-        .mockReturnValue(Promise.resolve(compression));
-
-    await run();
-
-    expect(reserveCacheMock).toHaveBeenCalledTimes(1);
-    expect(reserveCacheMock).toHaveBeenCalledWith(primaryKey, {
-        compressionMethod: compression
-    });
-
-    const archiveFolder = "/foo/bar";
-    const archiveFile = path.join(archiveFolder, CacheFilename.Zstd);
-
-    expect(createTarMock).toHaveBeenCalledTimes(1);
-    expect(createTarMock).toHaveBeenCalledWith(
-        archiveFolder,
-        cachePaths,
-        compression
-    );
-
-    expect(saveCacheMock).toHaveBeenCalledTimes(1);
-    expect(saveCacheMock).toHaveBeenCalledWith(cacheId, archiveFile);
-
-    expect(logWarningMock).toHaveBeenCalledTimes(1);
-    expect(logWarningMock).toHaveBeenCalledWith("HTTP Error Occurred");
-
-    expect(failedMock).toHaveBeenCalledTimes(0);
-    expect(getCompressionMock).toHaveBeenCalledTimes(1);
-});
-
-test("save with valid inputs uploads a cache", async () => {
-    const failedMock = jest.spyOn(core, "setFailed");
-
-    const primaryKey = "Linux-node-bb828da54c148048dd17899ba9fda624811cfb43";
-    const cacheEntry: ArtifactCacheEntry = {
-        cacheKey: "Linux-node-",
-        scope: "refs/heads/master",
-        creationTime: "2019-11-13T19:18:02+00:00",
-        archiveLocation: "www.actionscache.test/download"
-    };
-
-    jest.spyOn(core, "getState")
-        // Cache Entry State
-        .mockImplementationOnce(() => {
-            return JSON.stringify(cacheEntry);
-        })
-        // Cache Key State
-        .mockImplementationOnce(() => {
-            return primaryKey;
-        });
-
-    const inputPath = "node_modules";
-    const cachePaths = [path.resolve(inputPath)];
-    testUtils.setInput(Inputs.Path, inputPath);
-
-    const cacheId = 4;
-    const reserveCacheMock = jest
-        .spyOn(cacheHttpClient, "reserveCache")
-        .mockImplementationOnce(() => {
-            return Promise.resolve(cacheId);
-        });
-
-    const createTarMock = jest.spyOn(tar, "createTar");
-
-    const saveCacheMock = jest.spyOn(cacheHttpClient, "saveCache");
-    const compression = CompressionMethod.Zstd;
-    const getCompressionMock = jest
-        .spyOn(actionUtils, "getCompressionMethod")
-        .mockReturnValue(Promise.resolve(compression));
-
-    await run();
-
-    expect(reserveCacheMock).toHaveBeenCalledTimes(1);
-    expect(reserveCacheMock).toHaveBeenCalledWith(primaryKey, {
-        compressionMethod: compression
-    });
-
-    const archiveFolder = "/foo/bar";
-    const archiveFile = path.join(archiveFolder, CacheFilename.Zstd);
-
-    expect(createTarMock).toHaveBeenCalledTimes(1);
-    expect(createTarMock).toHaveBeenCalledWith(
-        archiveFolder,
-        cachePaths,
-        compression
-    );
-
-    expect(saveCacheMock).toHaveBeenCalledTimes(1);
-    expect(saveCacheMock).toHaveBeenCalledWith(cacheId, archiveFile);
-
-    expect(failedMock).toHaveBeenCalledTimes(0);
-    expect(getCompressionMock).toHaveBeenCalledTimes(1);
-});

__tests__/tar.test.ts

@@ -1,204 +0,0 @@
-import * as exec from "@actions/exec";
-import * as io from "@actions/io";
-import * as path from "path";
-
-import { CacheFilename, CompressionMethod } from "../src/constants";
-import * as tar from "../src/tar";
-import * as utils from "../src/utils/actionUtils";
-
-import fs = require("fs");
-
-jest.mock("@actions/exec");
-jest.mock("@actions/io");
-
-const IS_WINDOWS = process.platform === "win32";
-
-function getTempDir(): string {
-    return path.join(__dirname, "_temp", "tar");
-}
-
-beforeAll(async () => {
-    jest.spyOn(io, "which").mockImplementation(tool => {
-        return Promise.resolve(tool);
-    });
-
-    process.env["GITHUB_WORKSPACE"] = process.cwd();
-    await jest.requireActual("@actions/io").rmRF(getTempDir());
-});
-
-afterAll(async () => {
-    delete process.env["GITHUB_WORKSPACE"];
-    await jest.requireActual("@actions/io").rmRF(getTempDir());
-});
-
-test("zstd extract tar", async () => {
-    const mkdirMock = jest.spyOn(io, "mkdirP");
-    const execMock = jest.spyOn(exec, "exec");
-
-    const archivePath = IS_WINDOWS
-        ? `${process.env["windir"]}\\fakepath\\cache.tar`
-        : "cache.tar";
-    const workspace = process.env["GITHUB_WORKSPACE"];
-
-    await tar.extractTar(archivePath, CompressionMethod.Zstd);
-
-    expect(mkdirMock).toHaveBeenCalledWith(workspace);
-    const tarPath = IS_WINDOWS
-        ? `${process.env["windir"]}\\System32\\tar.exe`
-        : "tar";
-    expect(execMock).toHaveBeenCalledTimes(1);
-    expect(execMock).toHaveBeenCalledWith(
-        `"${tarPath}"`,
-        [
-            "--use-compress-program",
-            "zstd -d --long=30",
-            "-xf",
-            IS_WINDOWS ? archivePath.replace(/\\/g, "/") : archivePath,
-            "-P",
-            "-C",
-            IS_WINDOWS ? workspace?.replace(/\\/g, "/") : workspace
-        ],
-        { cwd: undefined }
-    );
-});
-
-test("gzip extract tar", async () => {
-    const mkdirMock = jest.spyOn(io, "mkdirP");
-    const execMock = jest.spyOn(exec, "exec");
-    const archivePath = IS_WINDOWS
-        ? `${process.env["windir"]}\\fakepath\\cache.tar`
-        : "cache.tar";
-    const workspace = process.env["GITHUB_WORKSPACE"];
-
-    await tar.extractTar(archivePath, CompressionMethod.Gzip);
-
-    expect(mkdirMock).toHaveBeenCalledWith(workspace);
-    const tarPath = IS_WINDOWS
-        ? `${process.env["windir"]}\\System32\\tar.exe`
-        : "tar";
-    expect(execMock).toHaveBeenCalledTimes(1);
-    expect(execMock).toHaveBeenCalledWith(
-        `"${tarPath}"`,
-        [
-            "-z",
-            "-xf",
-            IS_WINDOWS ? archivePath.replace(/\\/g, "/") : archivePath,
-            "-P",
-            "-C",
-            IS_WINDOWS ? workspace?.replace(/\\/g, "/") : workspace
-        ],
-        { cwd: undefined }
-    );
-});
-
-test("gzip extract GNU tar on windows", async () => {
-    if (IS_WINDOWS) {
-        jest.spyOn(fs, "existsSync").mockReturnValueOnce(false);
-
-        const isGnuMock = jest
-            .spyOn(utils, "useGnuTar")
-            .mockReturnValue(Promise.resolve(true));
-        const execMock = jest.spyOn(exec, "exec");
-        const archivePath = `${process.env["windir"]}\\fakepath\\cache.tar`;
-        const workspace = process.env["GITHUB_WORKSPACE"];
-
-        await tar.extractTar(archivePath, CompressionMethod.Gzip);
-
-        expect(isGnuMock).toHaveBeenCalledTimes(1);
-        expect(execMock).toHaveBeenCalledTimes(1);
-        expect(execMock).toHaveBeenCalledWith(
-            `"tar"`,
-            [
-                "-z",
-                "-xf",
-                archivePath.replace(/\\/g, "/"),
-                "-P",
-                "-C",
-                workspace?.replace(/\\/g, "/"),
-                "--force-local"
-            ],
-            { cwd: undefined }
-        );
-    }
-});
-
-test("zstd create tar", async () => {
-    const execMock = jest.spyOn(exec, "exec");
-
-    const archiveFolder = getTempDir();
-    const workspace = process.env["GITHUB_WORKSPACE"];
-    const sourceDirectories = ["~/.npm/cache", `${workspace}/dist`];
-
-    await fs.promises.mkdir(archiveFolder, { recursive: true });
-
-    await tar.createTar(
-        archiveFolder,
-        sourceDirectories,
-        CompressionMethod.Zstd
-    );
-
-    const tarPath = IS_WINDOWS
-        ? `${process.env["windir"]}\\System32\\tar.exe`
-        : "tar";
-
-    expect(execMock).toHaveBeenCalledTimes(1);
-    expect(execMock).toHaveBeenCalledWith(
-        `"${tarPath}"`,
-        [
-            "--use-compress-program",
-            "zstd -T0 --long=30",
-            "-cf",
-            IS_WINDOWS
-                ? CacheFilename.Zstd.replace(/\\/g, "/")
-                : CacheFilename.Zstd,
-            "-P",
-            "-C",
-            IS_WINDOWS ? workspace?.replace(/\\/g, "/") : workspace,
-            "--files-from",
-            "manifest.txt"
-        ],
-        {
-            cwd: archiveFolder
-        }
-    );
-});
-
-test("gzip create tar", async () => {
-    const execMock = jest.spyOn(exec, "exec");
-
-    const archiveFolder = getTempDir();
-    const workspace = process.env["GITHUB_WORKSPACE"];
-    const sourceDirectories = ["~/.npm/cache", `${workspace}/dist`];
-
-    await fs.promises.mkdir(archiveFolder, { recursive: true });
-
-    await tar.createTar(
-        archiveFolder,
-        sourceDirectories,
-        CompressionMethod.Gzip
-    );
-
-    const tarPath = IS_WINDOWS
-        ? `${process.env["windir"]}\\System32\\tar.exe`
-        : "tar";
-
-    expect(execMock).toHaveBeenCalledTimes(1);
-    expect(execMock).toHaveBeenCalledWith(
-        `"${tarPath}"`,
-        [
-            "-z",
-            "-cf",
-            IS_WINDOWS
-                ? CacheFilename.Gzip.replace(/\\/g, "/")
-                : CacheFilename.Gzip,
-            "-P",
-            "-C",
-            IS_WINDOWS ? workspace?.replace(/\\/g, "/") : workspace,
-            "--files-from",
-            "manifest.txt"
-        ],
-        {
-            cwd: archiveFolder
-        }
-    );
-});

__tests__/verify-cache-files.sh

@@ -1,36 +0,0 @@
-#!/bin/sh
-
-# Validate args
-prefix="$1"
-if [ -z "$prefix" ]; then
-  echo "Must supply prefix argument"
-  exit 1
-fi
-
-path="$2"
-if [ -z "$path" ]; then
-  echo "Must specify path argument"
-  exit 1
-fi
-
-# Sanity check GITHUB_RUN_ID defined
-if [ -z "$GITHUB_RUN_ID" ]; then
-  echo "GITHUB_RUN_ID not defined"
-  exit 1
-fi
-
-# Verify file exists
-file="$path/test-file.txt"
-echo "Checking for $file"
-if [ ! -e $file ]; then
-  echo "File does not exist"
-  exit 1
-fi
-
-# Verify file content
-content="$(cat $file)"
-echo "File content:\n$content"
-if [ -z "$(echo $content | grep --fixed-strings "$prefix $GITHUB_RUN_ID")" ]; then
-  echo "Unexpected file content"
-  exit 1
-fi

action.yml

@@ -1,5 +1,5 @@
 name: 'Cache'
-description: 'Cache artifacts like dependencies and build outputs to improve workflow execution time'
+description: 'Cache dependencies and build outputs to improve workflow execution time'
 author: 'GitHub'
 inputs:
   path:

examples.md

@@ -1,36 +1,18 @@
 # Examples
 
-- [Examples](#examples)
+- [C# - Nuget](#c---nuget)
-  - [C# - NuGet](#c---nuget)
+- [Elixir - Mix](#elixir---mix)
-  - [Elixir - Mix](#elixir---mix)
+- [Go - Modules](#go---modules)
-  - [Go - Modules](#go---modules)
+- [Java - Gradle](#java---gradle)
-  - [Haskell - Cabal](#haskell---cabal)
+- [Java - Maven](#java---maven)
-  - [Java - Gradle](#java---gradle)
+- [Node - npm](#node---npm)
-  - [Java - Maven](#java---maven)
+- [Node - Yarn](#node---yarn)
-  - [Node - npm](#node---npm)
+- [Ruby - Gem](#ruby---gem)
-    - [macOS and Ubuntu](#macos-and-ubuntu)
+- [Rust - Cargo](#rust---cargo)
-    - [Windows](#windows)
+- [Swift, Objective-C - Carthage](#swift-objective-c---carthage)
-    - [Using multiple systems and `npm config`](#using-multiple-systems-and-npm-config)
+- [Swift, Objective-C - CocoaPods](#swift-objective-c---cocoapods)
-  - [Node - Lerna](#node---lerna)
-  - [Node - Yarn](#node---yarn)
-  - [OCaml/Reason - esy](#ocamlreason---esy)
-  - [PHP - Composer](#php---composer)
-  - [Python - pip](#python---pip)
-    - [Simple example](#simple-example)
-    - [Multiple OS's in a workflow](#multiple-oss-in-a-workflow)
-    - [Using pip to get cache location](#using-pip-to-get-cache-location)
-    - [Using a script to get cache location](#using-a-script-to-get-cache-location)
-  - [R - renv](#r---renv)
-    - [Simple example](#simple-example-1)
-    - [Multiple OS's in a workflow](#multiple-oss-in-a-workflow-1)
-  - [Ruby - Bundler](#ruby---bundler)
-  - [Rust - Cargo](#rust---cargo)
-  - [Scala - SBT](#scala---sbt)
-  - [Swift, Objective-C - Carthage](#swift-objective-c---carthage)
-  - [Swift, Objective-C - CocoaPods](#swift-objective-c---cocoapods)
-  - [Swift - Swift Package Manager](#swift---swift-package-manager)
 
-## C# - NuGet
+## C# - Nuget
 Using [NuGet lock files](https://docs.microsoft.com/nuget/consume-packages/package-references-in-project-files#locking-dependencies):
 
 ```yaml
@@ -42,21 +24,6 @@ Using [NuGet lock files](https://docs.microsoft.com/nuget/consume-packages/packa
       ${{ runner.os }}-nuget-
 ```
 
-Depending on the environment, huge packages might be pre-installed in the global cache folder.
-If you do not want to include them, consider to move the cache folder like below.
->Note: This workflow does not work for projects that require files to be placed in user profile package folder
-```yaml
-env:
-  NUGET_PACKAGES: ${{ github.workspace }}/.nuget/packages
-steps:
-  - uses: actions/cache@v1
-    with:
-      path: ${{ github.workspace }}/.nuget/packages
-      key: ${{ runner.os }}-nuget-${{ hashFiles('**/packages.lock.json') }}
-      restore-keys: |
-        ${{ runner.os }}-nuget-
-```
-
 ## Elixir - Mix
 ```yaml
 - uses: actions/cache@v1
@@ -78,35 +45,13 @@ steps:
       ${{ runner.os }}-go-
 ```
 
-## Haskell - Cabal
-
-We cache the elements of the Cabal store separately, as the entirety of `~/.cabal` can grow very large for projects with many dependencies.
-
-```yaml
-- uses: actions/cache@v1
-  name: Cache ~/.cabal/packages
-  with:
-    path: ~/.cabal/packages
-    key: ${{ runner.os }}-${{ matrix.ghc }}-cabal-packages
-- uses: actions/cache@v1
-  name: Cache ~/.cabal/store
-  with:
-    path: ~/.cabal/store
-    key: ${{ runner.os }}-${{ matrix.ghc }}-cabal-store
-- uses: actions/cache@v1
-  name: Cache dist-newstyle
-  with:
-    path: dist-newstyle
-    key: ${{ runner.os }}-${{ matrix.ghc }}-dist-newstyle
-```
-
 ## Java - Gradle
 
 ```yaml
 - uses: actions/cache@v1
   with:
     path: ~/.gradle/caches
-    key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*') }}
+    key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle') }}
     restore-keys: |
       ${{ runner.os }}-gradle-
 ```
@@ -124,274 +69,35 @@ We cache the elements of the Cabal store separately, as the entirety of `~/.caba
 
 ## Node - npm
 
-For npm, cache files are stored in `~/.npm` on Posix, or `%AppData%/npm-cache` on Windows. See https://docs.npmjs.com/cli/cache#cache
-
->Note: It is not recommended to cache `node_modules`, as it can break across Node versions and won't work with `npm ci`
-
-### macOS and Ubuntu
-
 ```yaml
 - uses: actions/cache@v1
   with:
-    path: ~/.npm
+    path: node_modules
     key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
     restore-keys: |
       ${{ runner.os }}-node-
 ```
 
-### Windows
-
-```yaml
-- name: Get npm cache directory
-  id: npm-cache
-  run: |
-    echo "::set-output name=dir::$(npm config get cache)"
-- uses: actions/cache@v1
-  with:
-    path: ${{ steps.npm-cache.outputs.dir }}
-    key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
-    restore-keys: |
-      ${{ runner.os }}-node-
-```
-
-### Using multiple systems and `npm config`
-
-```yaml
-- name: Get npm cache directory
-  id: npm-cache
-  run: |
-    echo "::set-output name=dir::$(npm config get cache)"
-- uses: actions/cache@v1
-  with:
-    path: ${{ steps.npm-cache.outputs.dir }}
-    key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
-    restore-keys: |
-      ${{ runner.os }}-node-
-```
-
-## Node - Lerna
-
->Note this example uses the new multi-paths feature and is only available at `master`
-```yaml
-- name: restore lerna
-  uses: actions/cache@master
-  with:
-    path: |
-      node_modules
-      */*/node_modules
-    key: ${{ runner.os }}-${{ hashFiles('**/yarn.lock') }}
-```
-
 ## Node - Yarn
-The yarn cache directory will depend on your operating system and version of `yarn`. See https://yarnpkg.com/lang/en/docs/cli/cache/ for more info.
 
 ```yaml
-- name: Get yarn cache directory path
-  id: yarn-cache-dir-path
-  run: echo "::set-output name=dir::$(yarn cache dir)"
-
 - uses: actions/cache@v1
-  id: yarn-cache # use this to check for `cache-hit` (`steps.yarn-cache.outputs.cache-hit != 'true'`)
   with:
-    path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
+    path: ~/.cache/yarn
-    key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
+    key: ${{ runner.os }}-yarn-${{ hashFiles(format('{0}{1}', github.workspace, '/yarn.lock')) }}
     restore-keys: |
       ${{ runner.os }}-yarn-
 ```
 
-## OCaml/Reason - esy
+## Ruby - Gem
-Esy allows you to export built dependencies and import pre-built dependencies.
-```yaml
-    - name: Restore Cache
-      id: restore-cache
-      uses: actions/cache@v1
-      with:
-        path: _export
-        key:  ${{ runner.os }}-esy-${{ hashFiles('esy.lock/index.json') }}
-        restore-keys: |
-          ${{ runner.os }}-esy-
-    - name: Esy install
-      run: 'esy install'
-    - name: Import Cache
-      run: |
-        esy import-dependencies _export
-        rm -rf _export
-
-    ...(Build job)...
-
-    # Re-export dependencies if anything has changed or if it is the first time
-    - name: Setting dependency cache 
-      run: |
-        esy export-dependencies
-      if: steps.restore-cache.outputs.cache-hit != 'true'
-```
-
-
-## PHP - Composer
-
-```yaml
-- name: Get Composer Cache Directory
-  id: composer-cache
-  run: |
-    echo "::set-output name=dir::$(composer config cache-files-dir)"
-- uses: actions/cache@v1
-  with:
-    path: ${{ steps.composer-cache.outputs.dir }}
-    key: ${{ runner.os }}-composer-${{ hashFiles('**/composer.lock') }}
-    restore-keys: |
-      ${{ runner.os }}-composer-
-```
-
-## Python - pip
-
-For pip, the cache directory will vary by OS. See https://pip.pypa.io/en/stable/reference/pip_install/#caching
-
-Locations:
- - Ubuntu: `~/.cache/pip`
- - Windows: `~\AppData\Local\pip\Cache`
- - macOS: `~/Library/Caches/pip`
-
-### Simple example
-```yaml
-- uses: actions/cache@v1
-  with:
-    path: ~/.cache/pip
-    key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
-    restore-keys: |
-      ${{ runner.os }}-pip-
-```
-
-Replace `~/.cache/pip` with the correct `path` if not using Ubuntu.
-
-### Multiple OS's in a workflow
-
-```yaml
-- uses: actions/cache@v1
-  if: startsWith(runner.os, 'Linux')
-  with:
-    path: ~/.cache/pip
-    key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
-    restore-keys: |
-      ${{ runner.os }}-pip-
-
-- uses: actions/cache@v1
-  if: startsWith(runner.os, 'macOS')
-  with:
-    path: ~/Library/Caches/pip
-    key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
-    restore-keys: |
-      ${{ runner.os }}-pip-
-
-- uses: actions/cache@v1
-  if: startsWith(runner.os, 'Windows')
-  with:
-    path: ~\AppData\Local\pip\Cache
-    key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
-    restore-keys: |
-      ${{ runner.os }}-pip-
-```
-
-### Using pip to get cache location
-
-> Note: This requires pip 20.1+
-```yaml
-- name: Get pip cache dir
-  id: pip-cache
-  run: |
-    echo "::set-output name=dir::$(pip cache dir)"
-
-- name: pip cache
-  uses: actions/cache@v1
-  with:
-    path: ${{ steps.pip-cache.outputs.dir }}
-    key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
-    restore-keys: |
-      ${{ runner.os }}-pip-
-```
-
-### Using a script to get cache location
-
-> Note: This uses an internal pip API and may not always work
-```yaml
-- name: Get pip cache dir
- id: pip-cache
- run: |
-   python -c "from pip._internal.locations import USER_CACHE_DIR; print('::set-output name=dir::' + USER_CACHE_DIR)"
-
-- uses: actions/cache@v1
-  with:
-    path: ${{ steps.pip-cache.outputs.dir }}
-    key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
-    restore-keys: |
-      ${{ runner.os }}-pip-
-```
-
-## R - renv
-
-For renv, the cache directory will vary by OS. Look at https://rstudio.github.io/renv/articles/renv.html#cache
-
-Locations:
- - Ubuntu: `~/.local/share/renv`
- - macOS: `~/Library/Application Support/renv`
- - Windows: `%LOCALAPPDATA%/renv`
-
-### Simple example
-```yaml
-- uses: actions/cache@v1
-  with:
-    path: ~/.local/share/renv
-    key: ${{ runner.os }}-renv-${{ hashFiles('**/renv.lock') }}
-    restore-keys: |
-      ${{ runner.os }}-renv-
-```
-
-Replace `~/.local/share/renv` with the correct `path` if not using Ubuntu.
-
-### Multiple OS's in a workflow
-
-```yaml
-- uses: actions/cache@v1
-  if: startsWith(runner.os, 'Linux')
-  with:
-    path: ~/.local/share/renv
-    key: ${{ runner.os }}-renv-${{ hashFiles('**/renv.lock') }}
-    restore-keys: |
-      ${{ runner.os }}-renv-
-
-- uses: actions/cache@v1
-  if: startsWith(runner.os, 'macOS')
-  with:
-    path: ~/Library/Application Support/renv
-    key: ${{ runner.os }}-renv-${{ hashFiles('**/renv.lock') }}
-    restore-keys: |
-      ${{ runner.os }}-renv-
-
-- uses: actions/cache@v1
-  if: startsWith(runner.os, 'Windows')
-  with:
-    path: ~\AppData\Local\renv
-    key: ${{ runner.os }}-renv-${{ hashFiles('**/renv.lock') }}
-    restore-keys: |
-      ${{ runner.os }}-renv-
-```
-
-## Ruby - Bundler
 
 ```yaml
 - uses: actions/cache@v1
   with:
     path: vendor/bundle
-    key: ${{ runner.os }}-gems-${{ hashFiles('**/Gemfile.lock') }}
+    key: ${{ runner.os }}-gem-${{ hashFiles('**/Gemfile.lock') }}
     restore-keys: |
-      ${{ runner.os }}-gems-
+      ${{ runner.os }}-gem-
-```
-When dependencies are installed later in the workflow, we must specify the same path for the bundler.
-
-```yaml
-- name: Bundle install
-  run: |
-    bundle config path vendor/bundle
-    bundle install --jobs 4 --retry 3
 ```
 
 ## Rust - Cargo
@@ -414,21 +120,6 @@ When dependencies are installed later in the workflow, we must specify the same
     key: ${{ runner.os }}-cargo-build-target-${{ hashFiles('**/Cargo.lock') }}
 ```
 
-## Scala - SBT
-
-```yaml
-- name: Cache SBT ivy cache
-  uses: actions/cache@v1
-  with:
-    path: ~/.ivy2/cache
-    key: ${{ runner.os }}-sbt-ivy-cache-${{ hashFiles('**/build.sbt') }}
-- name: Cache SBT
-  uses: actions/cache@v1
-  with:
-    path: ~/.sbt
-    key: ${{ runner.os }}-sbt-${{ hashFiles('**/build.sbt') }}
-```
-
 ## Swift, Objective-C - Carthage
 
 ```yaml
@@ -450,14 +141,3 @@ When dependencies are installed later in the workflow, we must specify the same
     restore-keys: |
       ${{ runner.os }}-pods-
 ```
-
-## Swift - Swift Package Manager
-
-```yaml
-- uses: actions/cache@v1
-  with:
-    path: .build
-    key: ${{ runner.os }}-spm-${{ hashFiles('**/Package.resolved') }}
-    restore-keys: |
-      ${{ runner.os }}-spm-
-```

jest.config.js

@@ -1,23 +1,20 @@
-require("nock").disableNetConnect();
-
 module.exports = {
-    clearMocks: true,
+  clearMocks: true,
-    moduleFileExtensions: ["js", "ts"],
+  moduleFileExtensions: ['js', 'ts'],
-    testEnvironment: "node",
+  testEnvironment: 'node',
-    testMatch: ["**/*.test.ts"],
+  testMatch: ['**/*.test.ts'],
-    testRunner: "jest-circus/runner",
+  testRunner: 'jest-circus/runner',
-    transform: {
+  transform: {
-        "^.+\\.ts$": "ts-jest"
+    '^.+\\.ts$': 'ts-jest'
-    },
+  },
-    verbose: true
+  verbose: true
-};
+}
 
-const processStdoutWrite = process.stdout.write.bind(process.stdout);
+const processStdoutWrite = process.stdout.write.bind(process.stdout)
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 process.stdout.write = (str, encoding, cb) => {
-    // Core library will directly call process.stdout.write for commands
+  // Core library will directly call process.stdout.write for commands
-    // We don't want :: commands to be executed by the runner during tests
+  // We don't want :: commands to be executed by the runner during tests
-    if (!str.match(/^::/)) {
+  if (!str.match(/^::/)) {
-        return processStdoutWrite(str, encoding, cb);
+    return processStdoutWrite(str, encoding, cb);
-    }
+  }
-};
+}

package.json

@@ -1,15 +1,15 @@
 {
   "name": "cache",
-  "version": "1.1.2",
+  "version": "1.0.1",
   "private": true,
   "description": "Cache dependencies and build outputs",
   "main": "dist/restore/index.js",
   "scripts": {
-    "build": "tsc && ncc build -o dist/restore src/restore.ts && ncc build -o dist/save src/save.ts",
+    "build": "tsc",
     "test": "tsc --noEmit && jest --coverage",
-    "lint": "eslint **/*.ts --cache",
     "format": "prettier --write **/*.ts",
-    "format-check": "prettier --check **/*.ts"
+    "format-check": "prettier --check **/*.ts",
+    "release": "ncc build -o dist/restore src/restore.ts && ncc build -o dist/save src/save.ts && git add -f dist/"
   },
   "repository": {
     "type": "git",
@@ -25,30 +25,19 @@
   "dependencies": {
     "@actions/core": "^1.2.0",
     "@actions/exec": "^1.0.1",
-    "@actions/glob": "^0.1.0",
-    "@actions/http-client": "^1.0.8",
     "@actions/io": "^1.0.1",
+    "typed-rest-client": "^1.5.0",
     "uuid": "^3.3.3"
   },
   "devDependencies": {
     "@types/jest": "^24.0.13",
-    "@types/nock": "^11.1.0",
     "@types/node": "^12.0.4",
     "@types/uuid": "^3.4.5",
-    "@typescript-eslint/eslint-plugin": "^2.7.0",
-    "@typescript-eslint/parser": "^2.7.0",
     "@zeit/ncc": "^0.20.5",
-    "eslint": "^6.6.0",
-    "eslint-config-prettier": "^6.5.0",
-    "eslint-plugin-import": "^2.18.2",
-    "eslint-plugin-jest": "^23.0.3",
-    "eslint-plugin-prettier": "^3.1.1",
-    "eslint-plugin-simple-import-sort": "^5.0.2",
     "jest": "^24.8.0",
     "jest-circus": "^24.7.1",
-    "nock": "^11.7.0",
+    "prettier": "1.18.2",
-    "prettier": "^1.19.1",
     "ts-jest": "^24.0.2",
-    "typescript": "^3.7.3"
+    "typescript": "^3.6.4"
   }
 }

src/cacheHttpClient.ts

@@ -1,420 +1,124 @@
 import * as core from "@actions/core";
-import { HttpClient, HttpCodes } from "@actions/http-client";
-import { BearerCredentialHandler } from "@actions/http-client/auth";
-import {
-    IHttpClientResponse,
-    IRequestOptions,
-    ITypedResponse
-} from "@actions/http-client/interfaces";
-import * as crypto from "crypto";
 import * as fs from "fs";
-import * as stream from "stream";
-import * as util from "util";
 
-import { CompressionMethod, Inputs, SocketTimeout } from "./constants";
+import { BearerCredentialHandler } from "typed-rest-client/Handlers";
-import {
+import { HttpClient } from "typed-rest-client/HttpClient";
-    ArtifactCacheEntry,
+import { IHttpClientResponse } from "typed-rest-client/Interfaces";
-    CacheOptions,
+import { RestClient, IRequestOptions } from "typed-rest-client/RestClient";
-    CommitCacheRequest,
-    ReserveCacheRequest,
-    ReserveCacheResponse
-} from "./contracts";
-import * as utils from "./utils/actionUtils";
 
-const versionSalt = "1.0";
+import { ArtifactCacheEntry } from "./contracts";
 
-function isSuccessStatusCode(statusCode?: number): boolean {
+export async function getCacheEntry(
-    if (!statusCode) {
+    keys: string[]
-        return false;
+): Promise<ArtifactCacheEntry | null> {
+    const cacheUrl = getCacheUrl();
+    const token = process.env["ACTIONS_RUNTIME_TOKEN"] || "";
+    const bearerCredentialHandler = new BearerCredentialHandler(token);
+
+    const resource = `_apis/artifactcache/cache?keys=${encodeURIComponent(
+        keys.join(",")
+    )}`;
+
+    const restClient = new RestClient("actions/cache", cacheUrl, [
+        bearerCredentialHandler
+    ]);
+
+    const response = await restClient.get<ArtifactCacheEntry>(
+        resource,
+        getRequestOptions()
+    );
+    if (response.statusCode === 204) {
+        return null;
     }
-    return statusCode >= 200 && statusCode < 300;
+    if (response.statusCode !== 200) {
+        throw new Error(`Cache service responded with ${response.statusCode}`);
+    }
+    const cacheResult = response.result;
+    core.debug(`Cache Result:`);
+    core.debug(JSON.stringify(cacheResult));
+    if (!cacheResult || !cacheResult.archiveLocation) {
+        throw new Error("Cache not found.");
+    }
+
+    return cacheResult;
 }
 
-function isServerErrorStatusCode(statusCode?: number): boolean {
+export async function downloadCache(
-    if (!statusCode) {
+    cacheEntry: ArtifactCacheEntry,
-        return true;
+    archivePath: string
-    }
+): Promise<void> {
-    return statusCode >= 500;
+    const stream = fs.createWriteStream(archivePath);
+    const httpClient = new HttpClient("actions/cache");
+    const downloadResponse = await httpClient.get(cacheEntry.archiveLocation!);
+    await pipeResponseToStream(downloadResponse, stream);
 }
 
-function isRetryableStatusCode(statusCode?: number): boolean {
+async function pipeResponseToStream(
-    if (!statusCode) {
+    response: IHttpClientResponse,
-        return false;
+    stream: NodeJS.WritableStream
-    }
+): Promise<void> {
-    const retryableStatusCodes = [
+    return new Promise(resolve => {
-        HttpCodes.BadGateway,
+        response.message.pipe(stream).on("close", () => {
-        HttpCodes.ServiceUnavailable,
+            resolve();
-        HttpCodes.GatewayTimeout
+        });
-    ];
+    });
-    return retryableStatusCodes.includes(statusCode);
 }
 
-function getCacheApiUrl(resource: string): string {
+export async function saveCache(stream: NodeJS.ReadableStream, key: string) {
-    // Ideally we just use ACTIONS_CACHE_URL
+    const cacheUrl = getCacheUrl();
-    const baseUrl: string = (
+    const token = process.env["ACTIONS_RUNTIME_TOKEN"] || "";
-        process.env["ACTIONS_CACHE_URL"] ||
+    const bearerCredentialHandler = new BearerCredentialHandler(token);
-        process.env["ACTIONS_RUNTIME_URL"] ||
+
-        ""
+    const resource = `_apis/artifactcache/cache/${encodeURIComponent(key)}`;
-    ).replace("pipelines", "artifactcache");
+    const postUrl = cacheUrl + resource;
-    if (!baseUrl) {
+
-        throw new Error(
+    const restClient = new RestClient("actions/cache", undefined, [
-            "Cache Service Url not found, unable to restore cache."
+        bearerCredentialHandler
-        );
+    ]);
+
+    const requestOptions = getRequestOptions();
+    requestOptions.additionalHeaders = {
+        "Content-Type": "application/octet-stream"
+    };
+
+    const response = await restClient.uploadStream<void>(
+        "POST",
+        postUrl,
+        stream,
+        requestOptions
+    );
+    if (response.statusCode !== 200) {
+        throw new Error(`Cache service responded with ${response.statusCode}`);
     }
 
-    const url = `${baseUrl}_apis/artifactcache/${resource}`;
+    core.info("Cache saved successfully");
-    core.debug(`Resource Url: ${url}`);
+}
-    return url;
+
+function getRequestOptions(): IRequestOptions {
+    const requestOptions: IRequestOptions = {
+        acceptHeader: createAcceptHeader("application/json", "5.2-preview.1")
+    };
+
+    return requestOptions;
 }
 
 function createAcceptHeader(type: string, apiVersion: string): string {
     return `${type};api-version=${apiVersion}`;
 }
 
-function getRequestOptions(): IRequestOptions {
+function getCacheUrl(): string {
-    const requestOptions: IRequestOptions = {
+    // Ideally we just use ACTIONS_CACHE_URL
-        headers: {
+    let cacheUrl: string = (
-            Accept: createAcceptHeader("application/json", "6.0-preview.1")
+        process.env["ACTIONS_CACHE_URL"] ||
-        }
+        process.env["ACTIONS_RUNTIME_URL"] ||
-    };
+        ""
-
+    ).replace("pipelines", "artifactcache");
-    return requestOptions;
+    if (!cacheUrl) {
-}
-
-function createHttpClient(): HttpClient {
-    const token = process.env["ACTIONS_RUNTIME_TOKEN"] || "";
-    const bearerCredentialHandler = new BearerCredentialHandler(token);
-
-    return new HttpClient(
-        "actions/cache",
-        [bearerCredentialHandler],
-        getRequestOptions()
-    );
-}
-
-export function getCacheVersion(compressionMethod?: CompressionMethod): string {
-    const components = [core.getInput(Inputs.Path, { required: true })].concat(
-        compressionMethod == CompressionMethod.Zstd ? [compressionMethod] : []
-    );
-
-    // Add salt to cache version to support breaking changes in cache entry
-    components.push(versionSalt);
-
-    return crypto
-        .createHash("sha256")
-        .update(components.join("|"))
-        .digest("hex");
-}
-
-export async function retry<T>(
-    name: string,
-    method: () => Promise<T>,
-    getStatusCode: (T) => number | undefined,
-    maxAttempts = 2
-): Promise<T> {
-    let response: T | undefined = undefined;
-    let statusCode: number | undefined = undefined;
-    let isRetryable = false;
-    let errorMessage = "";
-    let attempt = 1;
-
-    while (attempt <= maxAttempts) {
-        try {
-            response = await method();
-            statusCode = getStatusCode(response);
-
-            if (!isServerErrorStatusCode(statusCode)) {
-                return response;
-            }
-
-            isRetryable = isRetryableStatusCode(statusCode);
-            errorMessage = `Cache service responded with ${statusCode}`;
-        } catch (error) {
-            isRetryable = true;
-            errorMessage = error.message;
-        }
-
-        core.debug(
-            `${name} - Attempt ${attempt} of ${maxAttempts} failed with error: ${errorMessage}`
-        );
-
-        if (!isRetryable) {
-            core.debug(`${name} - Error is not retryable`);
-            break;
-        }
-
-        attempt++;
-    }
-
-    throw Error(`${name} failed: ${errorMessage}`);
-}
-
-export async function retryTypedResponse<T>(
-    name: string,
-    method: () => Promise<ITypedResponse<T>>,
-    maxAttempts = 2
-): Promise<ITypedResponse<T>> {
-    return await retry(
-        name,
-        method,
-        (response: ITypedResponse<T>) => response.statusCode,
-        maxAttempts
-    );
-}
-
-export async function retryHttpClientResponse<T>(
-    name: string,
-    method: () => Promise<IHttpClientResponse>,
-    maxAttempts = 2
-): Promise<IHttpClientResponse> {
-    return await retry(
-        name,
-        method,
-        (response: IHttpClientResponse) => response.message.statusCode,
-        maxAttempts
-    );
-}
-
-export async function getCacheEntry(
-    keys: string[],
-    options?: CacheOptions
-): Promise<ArtifactCacheEntry | null> {
-    const httpClient = createHttpClient();
-    const version = getCacheVersion(options?.compressionMethod);
-    const resource = `cache?keys=${encodeURIComponent(
-        keys.join(",")
-    )}&version=${version}`;
-
-    const response = await retryTypedResponse("getCacheEntry", () =>
-        httpClient.getJson<ArtifactCacheEntry>(getCacheApiUrl(resource))
-    );
-
-    if (response.statusCode === 204) {
-        return null;
-    }
-
-    const cacheResult = response.result;
-    const cacheDownloadUrl = cacheResult?.archiveLocation;
-    if (!cacheDownloadUrl) {
-        throw new Error("Cache not found.");
-    }
-    core.setSecret(cacheDownloadUrl);
-    core.debug(`Cache Result:`);
-    core.debug(JSON.stringify(cacheResult));
-
-    return cacheResult;
-}
-
-async function pipeResponseToStream(
-    response: IHttpClientResponse,
-    output: NodeJS.WritableStream
-): Promise<void> {
-    const pipeline = util.promisify(stream.pipeline);
-    await pipeline(response.message, output);
-}
-
-export async function downloadCache(
-    archiveLocation: string,
-    archivePath: string
-): Promise<void> {
-    const stream = fs.createWriteStream(archivePath);
-    const httpClient = new HttpClient("actions/cache");
-    const downloadResponse = await retryHttpClientResponse(
-        "downloadCache",
-        () => httpClient.get(archiveLocation)
-    );
-
-    // Abort download if no traffic received over the socket.
-    downloadResponse.message.socket.setTimeout(SocketTimeout, () => {
-        downloadResponse.message.destroy();
-        core.debug(
-            `Aborting download, socket timed out after ${SocketTimeout} ms`
-        );
-    });
-
-    await pipeResponseToStream(downloadResponse, stream);
-
-    // Validate download size.
-    const contentLengthHeader =
-        downloadResponse.message.headers["content-length"];
-
-    if (contentLengthHeader) {
-        const expectedLength = parseInt(contentLengthHeader);
-        const actualLength = utils.getArchiveFileSize(archivePath);
-
-        if (actualLength != expectedLength) {
-            throw new Error(
-                `Incomplete download. Expected file size: ${expectedLength}, actual file size: ${actualLength}`
-            );
-        }
-    } else {
-        core.debug("Unable to validate download, no Content-Length header");
-    }
-}
-
-// Reserve Cache
-export async function reserveCache(
-    key: string,
-    options?: CacheOptions
-): Promise<number> {
-    const httpClient = createHttpClient();
-    const version = getCacheVersion(options?.compressionMethod);
-
-    const reserveCacheRequest: ReserveCacheRequest = {
-        key,
-        version
-    };
-    const response = await retryTypedResponse("reserveCache", () =>
-        httpClient.postJson<ReserveCacheResponse>(
-            getCacheApiUrl("caches"),
-            reserveCacheRequest
-        )
-    );
-
-    return response?.result?.cacheId ?? -1;
-}
-
-function getContentRange(start: number, end: number): string {
-    // Format: `bytes start-end/filesize
-    // start and end are inclusive
-    // filesize can be *
-    // For a 200 byte chunk starting at byte 0:
-    // Content-Range: bytes 0-199/*
-    return `bytes ${start}-${end}/*`;
-}
-
-async function uploadChunk(
-    httpClient: HttpClient,
-    resourceUrl: string,
-    openStream: () => NodeJS.ReadableStream,
-    start: number,
-    end: number
-): Promise<void> {
-    core.debug(
-        `Uploading chunk of size ${end -
-            start +
-            1} bytes at offset ${start} with content range: ${getContentRange(
-            start,
-            end
-        )}`
-    );
-    const additionalHeaders = {
-        "Content-Type": "application/octet-stream",
-        "Content-Range": getContentRange(start, end)
-    };
-
-    const uploadChunkRequest = async (): Promise<IHttpClientResponse> => {
-        return await httpClient.sendStream(
-            "PATCH",
-            resourceUrl,
-            openStream(),
-            additionalHeaders
-        );
-    };
-
-    await retryHttpClientResponse(
-        `uploadChunk (start: ${start}, end: ${end})`,
-        uploadChunkRequest
-    );
-}
-
-function parseEnvNumber(key: string): number | undefined {
-    const value = Number(process.env[key]);
-    if (Number.isNaN(value) || value < 0) {
-        return undefined;
-    }
-    return value;
-}
-
-async function uploadFile(
-    httpClient: HttpClient,
-    cacheId: number,
-    archivePath: string
-): Promise<void> {
-    // Upload Chunks
-    const fileSize = fs.statSync(archivePath).size;
-    const resourceUrl = getCacheApiUrl(`caches/${cacheId.toString()}`);
-    const fd = fs.openSync(archivePath, "r");
-
-    const concurrency = parseEnvNumber("CACHE_UPLOAD_CONCURRENCY") ?? 4; // # of HTTP requests in parallel
-    const MAX_CHUNK_SIZE =
-        parseEnvNumber("CACHE_UPLOAD_CHUNK_SIZE") ?? 32 * 1024 * 1024; // 32 MB Chunks
-    core.debug(`Concurrency: ${concurrency} and Chunk Size: ${MAX_CHUNK_SIZE}`);
-
-    const parallelUploads = [...new Array(concurrency).keys()];
-    core.debug("Awaiting all uploads");
-    let offset = 0;
-
-    try {
-        await Promise.all(
-            parallelUploads.map(async () => {
-                while (offset < fileSize) {
-                    const chunkSize = Math.min(
-                        fileSize - offset,
-                        MAX_CHUNK_SIZE
-                    );
-                    const start = offset;
-                    const end = offset + chunkSize - 1;
-                    offset += MAX_CHUNK_SIZE;
-
-                    await uploadChunk(
-                        httpClient,
-                        resourceUrl,
-                        () =>
-                            fs.createReadStream(archivePath, {
-                                fd,
-                                start,
-                                end,
-                                autoClose: false
-                            }),
-                        start,
-                        end
-                    );
-                }
-            })
-        );
-    } finally {
-        fs.closeSync(fd);
-    }
-    return;
-}
-
-async function commitCache(
-    httpClient: HttpClient,
-    cacheId: number,
-    filesize: number
-): Promise<ITypedResponse<null>> {
-    const commitCacheRequest: CommitCacheRequest = { size: filesize };
-    return await retryTypedResponse("commitCache", () =>
-        httpClient.postJson<null>(
-            getCacheApiUrl(`caches/${cacheId.toString()}`),
-            commitCacheRequest
-        )
-    );
-}
-
-export async function saveCache(
-    cacheId: number,
-    archivePath: string
-): Promise<void> {
-    const httpClient = createHttpClient();
-
-    core.debug("Upload cache");
-    await uploadFile(httpClient, cacheId, archivePath);
-
-    // Commit Cache
-    core.debug("Commiting cache");
-    const cacheSize = utils.getArchiveFileSize(archivePath);
-    const commitCacheResponse = await commitCache(
-        httpClient,
-        cacheId,
-        cacheSize
-    );
-    if (!isSuccessStatusCode(commitCacheResponse.statusCode)) {
         throw new Error(
-            `Cache service responded with ${commitCacheResponse.statusCode} during commit cache.`
+            "Cache Service Url not found, unable to restore cache."
         );
     }
 
-    core.info("Cache saved successfully");
+    core.debug(`Cache Url: ${cacheUrl}`);
+    return cacheUrl;
 }

src/constants.ts

@@ -1,35 +1,14 @@
-export enum Inputs {
+export namespace Inputs {
-    Key = "key",
+    export const Key = "key";
-    Path = "path",
+    export const Path = "path";
-    RestoreKeys = "restore-keys"
+    export const RestoreKeys = "restore-keys";
 }
 
-export enum Outputs {
+export namespace Outputs {
-    CacheHit = "cache-hit"
+    export const CacheHit = "cache-hit";
 }
 
-export enum State {
+export namespace State {
-    CacheKey = "CACHE_KEY",
+    export const CacheKey = "CACHE_KEY";
-    CacheResult = "CACHE_RESULT"
+    export const CacheResult = "CACHE_RESULT";
 }
-
-export enum Events {
-    Key = "GITHUB_EVENT_NAME",
-    Push = "push",
-    PullRequest = "pull_request"
-}
-
-export enum CacheFilename {
-    Gzip = "cache.tgz",
-    Zstd = "cache.tzst"
-}
-
-export enum CompressionMethod {
-    Gzip = "gzip",
-    Zstd = "zstd"
-}
-
-// Socket timeout in milliseconds during download.  If no traffic is received
-// over the socket during this period, the socket is destroyed and the download
-// is aborted.
-export const SocketTimeout = 5000;

src/contracts.d.ts

@@ -1,25 +1,6 @@
-import { CompressionMethod } from "./constants";
-
 export interface ArtifactCacheEntry {
     cacheKey?: string;
     scope?: string;
     creationTime?: string;
     archiveLocation?: string;
 }
-
-export interface CommitCacheRequest {
-    size: number;
-}
-
-export interface ReserveCacheRequest {
-    key: string;
-    version?: string;
-}
-
-export interface ReserveCacheResponse {
-    cacheId: number;
-}
-
-export interface CacheOptions {
-    compressionMethod?: CompressionMethod;
-}

src/restore.ts

@@ -1,24 +1,21 @@
 import * as core from "@actions/core";
+import { exec } from "@actions/exec";
+import * as io from "@actions/io";
+
+import * as fs from "fs";
 import * as path from "path";
 
 import * as cacheHttpClient from "./cacheHttpClient";
-import { Events, Inputs, State } from "./constants";
+import { Inputs, State } from "./constants";
-import { extractTar } from "./tar";
 import * as utils from "./utils/actionUtils";
 
-async function run(): Promise<void> {
+async function run() {
     try {
         // Validate inputs, this can cause task failure
-        if (!utils.isValidEvent()) {
+        let cachePath = utils.resolvePath(
-            utils.logWarning(
+            core.getInput(Inputs.Path, { required: true })
-                `Event Validation Error: The event type ${
+        );
-                    process.env[Events.Key]
+        core.debug(`Cache Path: ${cachePath}`);
-                } is not supported. Only ${utils
-                    .getSupportedEvents()
-                    .join(", ")} events are supported at this time.`
-            );
-            return;
-        }
 
         const primaryKey = core.getInput(Inputs.Key, { required: true });
         core.saveState(State.CacheKey, primaryKey);
@@ -54,49 +51,48 @@ async function run(): Promise<void> {
             }
         }
 
-        const compressionMethod = await utils.getCompressionMethod();
-
         try {
-            const cacheEntry = await cacheHttpClient.getCacheEntry(keys, {
+            const cacheEntry = await cacheHttpClient.getCacheEntry(keys);
-                compressionMethod: compressionMethod
+            if (!cacheEntry) {
-            });
+                core.info(
-            if (!cacheEntry?.archiveLocation) {
+                    `Cache not found for input keys: ${keys.join(", ")}.`
-                core.info(`Cache not found for input keys: ${keys.join(", ")}`);
+                );
                 return;
             }
 
-            const archivePath = path.join(
+            let archivePath = path.join(
                 await utils.createTempDirectory(),
-                utils.getCacheFileName(compressionMethod)
+                "cache.tgz"
             );
             core.debug(`Archive Path: ${archivePath}`);
 
             // Store the cache result
             utils.setCacheState(cacheEntry);
 
-            try {
+            // Download the cache from the cache entry
-                // Download the cache from the cache entry
+            await cacheHttpClient.downloadCache(cacheEntry, archivePath);
-                await cacheHttpClient.downloadCache(
-                    cacheEntry.archiveLocation,
-                    archivePath
-                );
 
-                const archiveFileSize = utils.getArchiveFileSize(archivePath);
+            io.mkdirP(cachePath);
-                core.info(
-                    `Cache Size: ~${Math.round(
-                        archiveFileSize / (1024 * 1024)
-                    )} MB (${archiveFileSize} B)`
-                );
 
-                await extractTar(archivePath, compressionMethod);
+            // http://man7.org/linux/man-pages/man1/tar.1.html
-            } finally {
+            // tar [-options] <name of the tar archive> [files or directories which to add into archive]
-                // Try to delete the archive to save space
+            const args = ["-xz"];
-                try {
+
-                    await utils.unlinkFile(archivePath);
+            const IS_WINDOWS = process.platform === "win32";
-                } catch (error) {
+            if (IS_WINDOWS) {
-                    core.debug(`Failed to delete archive: ${error}`);
+                args.push("--force-local");
-                }
+                archivePath = archivePath.replace(/\\/g, "/");
+                cachePath = cachePath.replace(/\\/g, "/");
             }
+            args.push(...["-f", archivePath, "-C", cachePath]);
+
+            const tarPath = await io.which("tar", true);
+            core.debug(`Tar Path: ${tarPath}`);
+
+            const archiveFileSize = fs.statSync(archivePath).size;
+            core.debug(`File Size: ${archiveFileSize}`);
+
+            await exec(`"${tarPath}"`, args);
 
             const isExactKeyMatch = utils.isExactKeyMatch(
                 primaryKey,
@@ -108,7 +104,7 @@ async function run(): Promise<void> {
                 `Cache restored from key: ${cacheEntry && cacheEntry.cacheKey}`
             );
         } catch (error) {
-            utils.logWarning(error.message);
+            core.warning(error.message);
             utils.setCacheHitOutput(false);
         }
     } catch (error) {

src/save.ts

@@ -1,30 +1,22 @@
 import * as core from "@actions/core";
+import { exec } from "@actions/exec";
+
+import * as io from "@actions/io";
+import * as fs from "fs";
 import * as path from "path";
 
 import * as cacheHttpClient from "./cacheHttpClient";
-import { Events, Inputs, State } from "./constants";
+import { Inputs, State } from "./constants";
-import { createTar } from "./tar";
 import * as utils from "./utils/actionUtils";
 
-async function run(): Promise<void> {
+async function run() {
     try {
-        if (!utils.isValidEvent()) {
-            utils.logWarning(
-                `Event Validation Error: The event type ${
-                    process.env[Events.Key]
-                } is not supported. Only ${utils
-                    .getSupportedEvents()
-                    .join(", ")} events are supported at this time.`
-            );
-            return;
-        }
-
         const state = utils.getCacheState();
 
         // Inputs are re-evaluted before the post action, so we want the original key used for restore
         const primaryKey = core.getState(State.CacheKey);
         if (!primaryKey) {
-            utils.logWarning(`Error retrieving key from state.`);
+            core.warning(`Error retrieving key from state.`);
             return;
         }
 
@@ -35,55 +27,47 @@ async function run(): Promise<void> {
             return;
         }
 
-        const compressionMethod = await utils.getCompressionMethod();
+        let cachePath = utils.resolvePath(
-
+            core.getInput(Inputs.Path, { required: true })
-        core.debug("Reserving Cache");
-        const cacheId = await cacheHttpClient.reserveCache(primaryKey, {
-            compressionMethod: compressionMethod
-        });
-        if (cacheId == -1) {
-            core.info(
-                `Unable to reserve cache with key ${primaryKey}, another job may be creating this cache.`
-            );
-            return;
-        }
-        core.debug(`Cache ID: ${cacheId}`);
-        const cachePaths = await utils.resolvePaths(
-            core
-                .getInput(Inputs.Path, { required: true })
-                .split("\n")
-                .filter(x => x !== "")
         );
+        core.debug(`Cache Path: ${cachePath}`);
 
-        core.debug("Cache Paths:");
+        let archivePath = path.join(
-        core.debug(`${JSON.stringify(cachePaths)}`);
+            await utils.createTempDirectory(),
-
+            "cache.tgz"
-        const archiveFolder = await utils.createTempDirectory();
-        const archivePath = path.join(
-            archiveFolder,
-            utils.getCacheFileName(compressionMethod)
         );
-
         core.debug(`Archive Path: ${archivePath}`);
 
-        await createTar(archiveFolder, cachePaths, compressionMethod);
+        // http://man7.org/linux/man-pages/man1/tar.1.html
+        // tar [-options] <name of the tar archive> [files or directories which to add into archive]
+        const args = ["-cz"];
+        const IS_WINDOWS = process.platform === "win32";
+        if (IS_WINDOWS) {
+            args.push("--force-local");
+            archivePath = archivePath.replace(/\\/g, "/");
+            cachePath = cachePath.replace(/\\/g, "/");
+        }
 
-        const fileSizeLimit = 5 * 1024 * 1024 * 1024; // 5GB per repo limit
+        args.push(...["-f", archivePath, "-C", cachePath, "."]);
-        const archiveFileSize = utils.getArchiveFileSize(archivePath);
+
+        const tarPath = await io.which("tar", true);
+        core.debug(`Tar Path: ${tarPath}`);
+        await exec(`"${tarPath}"`, args);
+
+        const fileSizeLimit = 400 * 1024 * 1024; // 400MB
+        const archiveFileSize = fs.statSync(archivePath).size;
         core.debug(`File Size: ${archiveFileSize}`);
         if (archiveFileSize > fileSizeLimit) {
-            utils.logWarning(
+            core.warning(
-                `Cache size of ~${Math.round(
+                `Cache size of ${archiveFileSize} bytes is over the 400MB limit, not saving cache.`
-                    archiveFileSize / (1024 * 1024)
-                )} MB (${archiveFileSize} B) is over the 5GB limit, not saving cache.`
             );
             return;
         }
 
-        core.debug(`Saving Cache (ID: ${cacheId})`);
+        const stream = fs.createReadStream(archivePath);
-        await cacheHttpClient.saveCache(cacheId, archivePath);
+        await cacheHttpClient.saveCache(stream, primaryKey);
     } catch (error) {
-        utils.logWarning(error.message);
+        core.warning(error.message);
     }
 }
 

src/tar.ts

@@ -1,87 +0,0 @@
-import { exec } from "@actions/exec";
-import * as io from "@actions/io";
-import { existsSync, writeFileSync } from "fs";
-import * as path from "path";
-
-import { CompressionMethod } from "./constants";
-import * as utils from "./utils/actionUtils";
-
-async function getTarPath(args: string[]): Promise<string> {
-    // Explicitly use BSD Tar on Windows
-    const IS_WINDOWS = process.platform === "win32";
-    if (IS_WINDOWS) {
-        const systemTar = `${process.env["windir"]}\\System32\\tar.exe`;
-        if (existsSync(systemTar)) {
-            return systemTar;
-        } else if (await utils.useGnuTar()) {
-            args.push("--force-local");
-        }
-    }
-    return await io.which("tar", true);
-}
-
-async function execTar(args: string[], cwd?: string): Promise<void> {
-    try {
-        await exec(`"${await getTarPath(args)}"`, args, { cwd: cwd });
-    } catch (error) {
-        throw new Error(`Tar failed with error: ${error?.message}`);
-    }
-}
-
-function getWorkingDirectory(): string {
-    return process.env["GITHUB_WORKSPACE"] ?? process.cwd();
-}
-
-export async function extractTar(
-    archivePath: string,
-    compressionMethod: CompressionMethod
-): Promise<void> {
-    // Create directory to extract tar into
-    const workingDirectory = getWorkingDirectory();
-    await io.mkdirP(workingDirectory);
-    // --d: Decompress.
-    // --long=#: Enables long distance matching with # bits. Maximum is 30 (1GB) on 32-bit OS and 31 (2GB) on 64-bit.
-    // Using 30 here because we also support 32-bit self-hosted runners.
-    const args = [
-        ...(compressionMethod == CompressionMethod.Zstd
-            ? ["--use-compress-program", "zstd -d --long=30"]
-            : ["-z"]),
-        "-xf",
-        archivePath.replace(new RegExp("\\" + path.sep, "g"), "/"),
-        "-P",
-        "-C",
-        workingDirectory.replace(new RegExp("\\" + path.sep, "g"), "/")
-    ];
-    await execTar(args);
-}
-
-export async function createTar(
-    archiveFolder: string,
-    sourceDirectories: string[],
-    compressionMethod: CompressionMethod
-): Promise<void> {
-    // Write source directories to manifest.txt to avoid command length limits
-    const manifestFilename = "manifest.txt";
-    const cacheFileName = utils.getCacheFileName(compressionMethod);
-    writeFileSync(
-        path.join(archiveFolder, manifestFilename),
-        sourceDirectories.join("\n")
-    );
-    // -T#: Compress using # working thread. If # is 0, attempt to detect and use the number of physical CPU cores.
-    // --long=#: Enables long distance matching with # bits. Maximum is 30 (1GB) on 32-bit OS and 31 (2GB) on 64-bit.
-    // Using 30 here because we also support 32-bit self-hosted runners.
-    const workingDirectory = getWorkingDirectory();
-    const args = [
-        ...(compressionMethod == CompressionMethod.Zstd
-            ? ["--use-compress-program", "zstd -T0 --long=30"]
-            : ["-z"]),
-        "-cf",
-        cacheFileName.replace(new RegExp("\\" + path.sep, "g"), "/"),
-        "-P",
-        "-C",
-        workingDirectory.replace(new RegExp("\\" + path.sep, "g"), "/"),
-        "--files-from",
-        manifestFilename
-    ];
-    await execTar(args, archiveFolder);
-}

src/utils/actionUtils.ts

@@ -1,20 +1,10 @@
 import * as core from "@actions/core";
-import * as exec from "@actions/exec";
-import * as glob from "@actions/glob";
 import * as io from "@actions/io";
-import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
-import * as util from "util";
 import * as uuidV4 from "uuid/v4";
 
-import {
+import { Outputs, State } from "../constants";
-    CacheFilename,
-    CompressionMethod,
-    Events,
-    Outputs,
-    State
-} from "../constants";
 import { ArtifactCacheEntry } from "../contracts";
 
 // From https://github.com/actions/toolkit/blob/master/packages/tool-cache/src/tool-cache.ts#L23
@@ -37,16 +27,11 @@ export async function createTempDirectory(): Promise<string> {
         }
         tempDirectory = path.join(baseLocation, "actions", "temp");
     }
-
     const dest = path.join(tempDirectory, uuidV4.default());
     await io.mkdirP(dest);
     return dest;
 }
 
-export function getArchiveFileSize(path: string): number {
-    return fs.statSync(path).size;
-}
-
 export function isExactKeyMatch(
     key: string,
     cacheResult?: ArtifactCacheEntry
@@ -60,18 +45,10 @@ export function isExactKeyMatch(
     );
 }
 
-export function setCacheState(state: ArtifactCacheEntry): void {
-    core.saveState(State.CacheResult, JSON.stringify(state));
-}
-
-export function setCacheHitOutput(isCacheHit: boolean): void {
-    core.setOutput(Outputs.CacheHit, isCacheHit.toString());
-}
-
 export function setOutputAndState(
     key: string,
     cacheResult?: ArtifactCacheEntry
-): void {
+) {
     setCacheHitOutput(isExactKeyMatch(key, cacheResult));
     // Store the cache result if it exists
     cacheResult && setCacheState(cacheResult);
@@ -80,93 +57,25 @@ export function setOutputAndState(
 export function getCacheState(): ArtifactCacheEntry | undefined {
     const stateData = core.getState(State.CacheResult);
     core.debug(`State: ${stateData}`);
-    if (stateData) {
+    return (stateData && JSON.parse(stateData)) as ArtifactCacheEntry;
-        return JSON.parse(stateData) as ArtifactCacheEntry;
+}
+
+export function setCacheState(state: ArtifactCacheEntry) {
+    core.saveState(State.CacheResult, JSON.stringify(state));
+}
+
+export function setCacheHitOutput(isCacheHit: boolean) {
+    core.setOutput(Outputs.CacheHit, isCacheHit.toString());
+}
+
+export function resolvePath(filePath: string): string {
+    if (filePath[0] === "~") {
+        const home = os.homedir();
+        if (!home) {
+            throw new Error("Unable to resolve `~` to HOME");
+        }
+        return path.join(home, filePath.slice(1));
     }
 
-    return undefined;
+    return path.resolve(filePath);
-}
-
-export function logWarning(message: string): void {
-    const warningPrefix = "[warning]";
-    core.info(`${warningPrefix}${message}`);
-}
-
-export async function resolvePaths(patterns: string[]): Promise<string[]> {
-    const paths: string[] = [];
-    const workspace = process.env["GITHUB_WORKSPACE"] ?? process.cwd();
-    const globber = await glob.create(patterns.join("\n"), {
-        implicitDescendants: false
-    });
-
-    for await (const file of globber.globGenerator()) {
-        const relativeFile = path.relative(workspace, file);
-        core.debug(`Matched: ${relativeFile}`);
-        // Paths are made relative so the tar entries are all relative to the root of the workspace.
-        paths.push(`${relativeFile}`);
-    }
-
-    return paths;
-}
-
-export function getSupportedEvents(): string[] {
-    return [Events.Push, Events.PullRequest];
-}
-
-// Currently the cache token is only authorized for push and pull_request events
-// All other events will fail when reading and saving the cache
-// See GitHub Context https://help.github.com/actions/automating-your-workflow-with-github-actions/contexts-and-expression-syntax-for-github-actions#github-context
-export function isValidEvent(): boolean {
-    const githubEvent = process.env[Events.Key] || "";
-    return getSupportedEvents().includes(githubEvent);
-}
-
-export function unlinkFile(path: fs.PathLike): Promise<void> {
-    return util.promisify(fs.unlink)(path);
-}
-
-async function getVersion(app: string): Promise<string> {
-    core.debug(`Checking ${app} --version`);
-    let versionOutput = "";
-    try {
-        await exec.exec(`${app} --version`, [], {
-            ignoreReturnCode: true,
-            silent: true,
-            listeners: {
-                stdout: (data: Buffer): string =>
-                    (versionOutput += data.toString()),
-                stderr: (data: Buffer): string =>
-                    (versionOutput += data.toString())
-            }
-        });
-    } catch (err) {
-        core.debug(err.message);
-    }
-
-    versionOutput = versionOutput.trim();
-    core.debug(versionOutput);
-    return versionOutput;
-}
-
-export async function getCompressionMethod(): Promise<CompressionMethod> {
-    // Disabling zstd on Windows due to https://github.com/actions/cache/issues/301
-    if (os.platform() === "win32") {
-        return CompressionMethod.Gzip;
-    }
-
-    const versionOutput = await getVersion("zstd");
-    return versionOutput.toLowerCase().includes("zstd command line interface")
-        ? CompressionMethod.Zstd
-        : CompressionMethod.Gzip;
-}
-
-export function getCacheFileName(compressionMethod: CompressionMethod): string {
-    return compressionMethod == CompressionMethod.Zstd
-        ? CacheFilename.Zstd
-        : CacheFilename.Gzip;
-}
-
-export async function useGnuTar(): Promise<boolean> {
-    const versionOutput = await getVersion("tar");
-    return versionOutput.toLowerCase().includes("gnu tar");
 }

src/utils/testUtils.ts

@@ -1,29 +1,7 @@
-import { Inputs } from "../constants";
-
-// See: https://github.com/actions/toolkit/blob/master/packages/core/src/core.ts#L67
 function getInputName(name: string): string {
     return `INPUT_${name.replace(/ /g, "_").toUpperCase()}`;
 }
 
-export function setInput(name: string, value: string): void {
+export function setInput(name: string, value: string) {
     process.env[getInputName(name)] = value;
 }
-
-interface CacheInput {
-    path: string;
-    key: string;
-    restoreKeys?: string[];
-}
-
-export function setInputs(input: CacheInput): void {
-    setInput(Inputs.Path, input.path);
-    setInput(Inputs.Key, input.key);
-    input.restoreKeys &&
-        setInput(Inputs.RestoreKeys, input.restoreKeys.join("\n"));
-}
-
-export function clearInputs(): void {
-    delete process.env[getInputName(Inputs.Path)];
-    delete process.env[getInputName(Inputs.Key)];
-    delete process.env[getInputName(Inputs.RestoreKeys)];
-}