Implementation of python's caching

.github/workflows/e2e-cache.yml

@@ -0,0 +1,91 @@
+name: e2e-cache
+
+on:
+  pull_request:
+    paths-ignore:
+      - '**.md'
+  push:
+    branches:
+      - main
+      - releases/*
+    paths-ignore:
+      - '**.md'
+
+jobs:
+  python-pip-depencies-caching:
+    name: Test pip (Python ${{ matrix.python-version}}, ${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        python-version: ['3.7', '3.8', '3.9', 'pypy-3.7-v7.3.5', 'pypy-3.7-v7.x']
+    steps:
+      - uses: actions/checkout@v2
+      - name: Setup Python
+        uses: ./
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: 'pip'
+      - name: Install dependencies
+        run: pip install numpy pandas requests
+
+  python-pipenv-depencies-caching:
+    name: Test pipenv (Python ${{ matrix.python-version}}, ${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        python-version: ['3.7', '3.8', '3.9', 'pypy-3.7-v7.3.5', 'pypy-3.7-v7.x']
+    steps:
+      - uses: actions/checkout@v2
+      - name: Install pipenv
+        run: pipx install pipenv
+      - name: Setup Python
+        uses: ./
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: 'pipenv'
+      - name: Install dependencies
+        run: pipenv install flake8
+
+  python-pip-depencies-caching-path:
+    name: Test pip (Python ${{ matrix.python-version}}, ${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        python-version: ['3.7', '3.8', '3.9', 'pypy-3.7-v7.3.5', 'pypy-3.7-v7.x']
+    steps:
+      - uses: actions/checkout@v2
+      - name: Setup Python
+        uses: ./
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: 'pip'
+          cache-dependency-path: __tests__/data/requirements.txt
+      - name: Install dependencies
+        run: pip install numpy pandas requests
+
+  python-pipenv-depencies-caching-path:
+    name: Test pipenv (Python ${{ matrix.python-version}}, ${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        python-version: ['3.7', '3.8', '3.9', 'pypy-3.7-v7.3.5', 'pypy-3.7-v7.x']
+    steps:
+      - uses: actions/checkout@v2
+      - name: Install pipenv
+        run: pipx install pipenv
+      - name: Setup Python
+        uses: ./
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: 'pipenv'
+          cache-dependency-path: '**/requirements-linux.txt'
+      - name: Install dependencies
+        run: pipenv install flake8

README.md

@@ -9,6 +9,7 @@ This action sets up a Python environment for use in actions by:
 - optionally installing and adding to PATH a version of Python that is already installed in the tools cache.
 - downloading, installing and adding to PATH an available version of Python from GitHub Releases ([actions/python-versions](https://github.com/actions/python-versions/releases)) if a specific version is not available in the tools cache.
 - failing if a specific version of Python is not preinstalled or available for download.
+- optionally caching dependencies for pip and pipenv.
 - registering problem matchers for error output.
 
 # What's new
@@ -18,6 +19,7 @@ This action sets up a Python environment for use in actions by:
 - Automatic setup and download of Python packages if using a self-hosted runner.
 - Support for pre-release versions of Python.
 - Support for installing any version of PyPy on-flight
+- Support for built-in caching of pip and pipenv dependencies
 
 # Usage
 
@@ -205,6 +207,72 @@ pypy-3.7-v7.3.3rc1 # Python 3.7 and preview version of PyPy
 pypy-3.7-nightly # Python 3.7 and nightly PyPy
 ```
 
+# Caching packages dependencies
+
+The action has a built-in functionality for caching and restoring dependencies. It uses [actions/cache](https://github.com/actions/cache) under hood for caching dependencies but requires less configuration settings. Supported package managers are `pip` and `pipenv`. The `cache` input is optional, and caching is turned off by default.
+
+The action defaults to search for the dependency file (`requirements.txt` for pip or `Pipfile.lock` for pipenv) in the repository, and uses its hash as a part of the cache key. Use `cache-dependency-path` for cases when multiple dependency files are used, they are located in different subdirectories or different files for hash want to be used.
+
+ - For pip action will cache global cache ditrectory
+ - For pipenv action will cache virtuenv directory
+
+**Caching pip dependencies:**  
+
+```yaml
+steps:
+- uses: actions/checkout@v2
+- uses: actions/setup-python@v2
+  with:
+    python-version: '3.9'
+    cache: 'pip'
+- run: pip install -r requirements.txt
+- run: pip test
+```
+
+**Caching pipenv dependencies:**
+```yaml
+steps:
+- uses: actions/checkout@v2
+- name: Install pipenv
+  run: pipx install pipenv
+- uses: actions/setup-python@v2
+  with:
+    python-version: '3.9'
+    cache: 'pipenv'
+- run: pipenv install
+- run: pipenv test
+```
+
+**Using wildcard patterns to cache dependencies**
+```yaml
+steps:
+- uses: actions/checkout@v2
+- uses: actions/setup-python@v2
+  with:
+    python-version: '3.9'
+    cache: 'pip'
+    cache-dependency-path: '**/requirements-dev.txt'
+- run: pip install -r subdirectory/requirements-dev.txt
+- run: pip test
+```
+
+**Using a list of file paths to cache dependencies**
+```yaml
+steps:
+- uses: actions/checkout@v2
+- name: Install pipenv
+  run: pipx install pipenv
+- uses: actions/setup-python@v2
+  with:
+    python-version: '3.9'
+    cache: 'pipenv'
+    cache-dependency-path: |
+      server/app/Pipfile.lock
+      __test__/app/Pipfile.lock
+- run: pipenv install
+- run: pipenv test
+```
+
 # Using `setup-python` with a self hosted runner
 
 Python distributions are only available for the same [environments](https://github.com/actions/virtual-environments#available-environments) that GitHub Actions hosted environments are available for. If you are using an unsupported version of Ubuntu such as `19.04` or another Linux distribution such as Fedora, `setup-python` will not work. If you have a supported self-hosted runner and you would like to use `setup-python`, there are a few extra things you need to make sure are set up so that new versions of Python can be downloaded and configured on your runner.

__tests__/cache-restore.test.ts

@@ -0,0 +1,175 @@
+import * as core from '@actions/core';
+import * as cache from '@actions/cache';
+import * as exec from '@actions/exec';
+import {getCacheDistributor} from '../src/cache-distributions/cache-factory';
+
+describe('restore-cache', () => {
+  const pipFileLockHash =
+    '67d817abcde9c72da0ed5b8f235647cb14638b9ff9d742b42e4406d2eb16fe3c';
+  const requirementsHash =
+    'd8110e0006d7fb5ee76365d565eef9d37df1d11598b912d3eb66d398d57a1121';
+  const requirementsLinuxHash =
+    '2d0ff7f46b0e120e3d3294db65768b474934242637b9899b873e6283dfd16d7c';
+
+  // core spy
+  let infoSpy: jest.SpyInstance;
+  let warningSpy: jest.SpyInstance;
+  let debugSpy: jest.SpyInstance;
+  let saveSatetSpy: jest.SpyInstance;
+  let getStateSpy: jest.SpyInstance;
+
+  // cache spy
+  let restoreCacheSpy: jest.SpyInstance;
+
+  // exec spy
+  let getExecOutputSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    process.env['RUNNER_OS'] = process.env['RUNNER_OS'] ?? 'linux';
+    // process.env['GITHUB_WORKSPACE'] = path.join(__dirname, 'data');
+    infoSpy = jest.spyOn(core, 'info');
+    infoSpy.mockImplementation(input => undefined);
+
+    warningSpy = jest.spyOn(core, 'warning');
+    warningSpy.mockImplementation(input => undefined);
+
+    debugSpy = jest.spyOn(core, 'debug');
+    debugSpy.mockImplementation(input => undefined);
+
+    saveSatetSpy = jest.spyOn(core, 'saveState');
+    saveSatetSpy.mockImplementation(input => undefined);
+
+    getStateSpy = jest.spyOn(core, 'getState');
+    getStateSpy.mockImplementation(input => undefined);
+
+    getExecOutputSpy = jest.spyOn(exec, 'getExecOutput');
+    getExecOutputSpy.mockImplementation((input: string) => {
+      if (input.includes('pip')) {
+        return {stdout: 'pip', stderr: '', exitCode: 0};
+      }
+
+      return {stdout: '', stderr: 'Error occured', exitCode: 2};
+    });
+
+    restoreCacheSpy = jest.spyOn(cache, 'restoreCache');
+    restoreCacheSpy.mockImplementation(
+      (cachePaths: string[], primaryKey: string, restoreKey?: string) => {
+        return primaryKey;
+      }
+    );
+  });
+
+  describe('Validate provided package manager', () => {
+    it.each(['npm', 'pip2', 'pip21', 'pip21.3', 'pipenv32'])(
+      'Throw an error because %s is not supported',
+      async packageManager => {
+        expect(() =>
+          getCacheDistributor(packageManager, '3.8.12', undefined)
+        ).toThrowError(`Caching for '${packageManager}' is not supported`);
+      }
+    );
+  });
+
+  describe('Restore dependencies', () => {
+    it.each([
+      ['pip', '3.8.12', undefined, requirementsHash],
+      ['pip', '3.8.12', '**/requirements-linux.txt', requirementsLinuxHash],
+      [
+        'pip',
+        '3.8.12',
+        '__tests__/data/requirements-linux.txt',
+        requirementsLinuxHash
+      ],
+      ['pip', '3.8.12', '__tests__/data/requirements.txt', requirementsHash],
+      ['pipenv', '3.9.1', undefined, pipFileLockHash],
+      ['pipenv', '3.9.12', '__tests__/data/requirements.txt', requirementsHash]
+    ])(
+      'restored dependencies for %s by primaryKey',
+      async (packageManager, pythonVersion, dependencyFile, fileHash) => {
+        const cacheDistributor = await getCacheDistributor(
+          packageManager,
+          pythonVersion,
+          dependencyFile
+        );
+        await cacheDistributor.restoreCache();
+        let pythonKey = '';
+        if (packageManager === 'pipenv') {
+          pythonKey = `python-${pythonVersion}-`;
+        }
+
+        expect(infoSpy).toHaveBeenCalledWith(
+          `Cache restored from key: setup-python-${process.env['RUNNER_OS']}-${pythonKey}${packageManager}-${fileHash}`
+        );
+      }
+    );
+
+    it.each([
+      ['pip', '3.8.12', 'requirements-linux.txt', 'requirements-linux.txt'],
+      ['pip', '3.8.12', 'requirements.txt', 'requirements.txt'],
+      ['pipenv', '3.9.12', 'requirements.txt', 'requirements.txt']
+    ])(
+      'Should throw an error because dependency file is not found',
+      async (
+        packageManager,
+        pythonVersion,
+        dependencyFile,
+        cacheDependencyPath
+      ) => {
+        const cacheDistributor = await getCacheDistributor(
+          packageManager,
+          pythonVersion,
+          dependencyFile
+        );
+        await expect(cacheDistributor.restoreCache()).rejects.toThrowError(
+          `No file in ${process.cwd()} matched to [${cacheDependencyPath
+            .split('\n')
+            .join(',')}], make sure you have checked out the target repository`
+        );
+      }
+    );
+  });
+
+  describe('Dependencies changed', () => {
+    it.each([
+      ['pip', '3.8.12', undefined, pipFileLockHash],
+      ['pip', '3.8.12', '**/requirements-linux.txt', pipFileLockHash],
+      [
+        'pip',
+        '3.8.12',
+        '__tests__/data/requirements-linux.txt',
+        pipFileLockHash
+      ],
+      ['pip', '3.8.12', '__tests__/data/requirements.txt', pipFileLockHash],
+      ['pipenv', '3.9.1', undefined, requirementsHash],
+      ['pipenv', '3.9.12', '__tests__/data/requirements.txt', requirementsHash]
+    ])(
+      'restored dependencies for %s by primaryKey',
+      async (packageManager, pythonVersion, dependencyFile, fileHash) => {
+        restoreCacheSpy.mockImplementation(
+          (cachePaths: string[], primaryKey: string, restoreKey?: string) => {
+            return primaryKey !== fileHash && restoreKey ? pipFileLockHash : '';
+          }
+        );
+        const cacheDistributor = await getCacheDistributor(
+          packageManager,
+          pythonVersion,
+          dependencyFile
+        );
+        await cacheDistributor.restoreCache();
+        let result = '';
+        if (packageManager !== 'pipenv') {
+          result = `Cache restored from key: ${fileHash}`;
+        } else {
+          result = 'pipenv cache is not found';
+        }
+
+        expect(infoSpy).toHaveBeenCalledWith(result);
+      }
+    );
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+    jest.clearAllMocks();
+  });
+});