build: inline external Github Actions to unblock CI (#12241)

* build: inline cached-dependencies to unblock CI

* Run E2E on pull_request on;y

* Inline all external actions

* Checkout needed for internal actions

Also fixes pre-commit

* Add missing files

.github/actions/cached-dependencies/__tests__/cache.test.ts

@@ -0,0 +1,124 @@
+import path from 'path';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as core from '@actions/core';
+import * as cache from '../src/cache';
+import * as inputsUtils from '../src/utils/inputs';
+import * as actionUtils from '@actions/cache/src/utils/actionUtils';
+import defaultCaches from '../src/cache/caches';
+import { setInputs, getInput, maybeArrayToString } from '../src/utils/inputs';
+import { Inputs, InputName, GitHubEvent, EnvVariable } from '../src/constants';
+import caches, { npmExpectedHash } from './fixtures/caches';
+
+describe('patch core states', () => {
+  it('should log error if states file invalid', () => {
+    const logWarningMock = jest.spyOn(actionUtils, 'logWarning');
+    fs.writeFileSync(`${os.tmpdir()}/cached--states.json`, 'INVALID_JSON', {
+      encoding: 'utf-8',
+    });
+    core.getState('haha');
+    expect(logWarningMock).toHaveBeenCalledTimes(2);
+  });
+  it('should persist state', () => {
+    core.saveState('test', '100');
+    expect(core.getState('test')).toStrictEqual('100');
+  });
+});
+
+describe('cache runner', () => {
+  it('should use default cache config', async () => {
+    await cache.loadCustomCacheConfigs();
+    // but `npm` actually come from `src/cache/caches.ts`
+    const inputs = await cache.getCacheInputs('npm');
+    expect(inputs?.[InputName.Path]).toStrictEqual(
+      maybeArrayToString(defaultCaches.npm.path),
+    );
+    expect(inputs?.[InputName.RestoreKeys]).toStrictEqual('npm-');
+  });
+
+  it('should override cache config', async () => {
+    setInputs({
+      [InputName.Caches]: path.resolve(__dirname, 'fixtures/caches'),
+    });
+    await cache.loadCustomCacheConfigs();
+
+    const inputs = await cache.getCacheInputs('npm');
+    expect(inputs?.[InputName.Path]).toStrictEqual(
+      maybeArrayToString(caches.npm.path),
+    );
+    expect(inputs?.[InputName.Key]).toStrictEqual(`npm-${npmExpectedHash}`);
+    expect(inputs?.[InputName.RestoreKeys]).toStrictEqual(
+      maybeArrayToString(caches.npm.restoreKeys),
+    );
+  });
+
+  it('should apply inputs and restore cache', async () => {
+    setInputs({
+      [InputName.Caches]: path.resolve(__dirname, 'fixtures/caches'),
+      [EnvVariable.GitHubEventName]: GitHubEvent.PullRequest,
+    });
+
+    const setInputsMock = jest.spyOn(inputsUtils, 'setInputs');
+    const inputs = await cache.getCacheInputs('npm');
+    const result = await cache.run('restore', 'npm');
+
+    expect(result).toBeUndefined();
+
+    // before run
+    expect(setInputsMock).toHaveBeenNthCalledWith(1, inputs);
+
+    // after run
+    expect(setInputsMock).toHaveBeenNthCalledWith(2, {
+      [InputName.Key]: '',
+      [InputName.Path]: '',
+      [InputName.RestoreKeys]: '',
+    });
+
+    // inputs actually restored to original value
+    expect(getInput(InputName.Key)).toStrictEqual('');
+
+    // pretend still in execution context
+    setInputs(inputs as Inputs);
+
+    // `core.getState` should return the primary key
+    expect(core.getState('CACHE_KEY')).toStrictEqual(inputs?.[InputName.Key]);
+
+    setInputsMock.mockRestore();
+  });
+
+  it('should run saveCache', async () => {
+    // call to save should also work
+    const logWarningMock = jest.spyOn(actionUtils, 'logWarning');
+
+    setInputs({
+      [InputName.Parallel]: 'true',
+    });
+    await cache.run('save', 'npm');
+    expect(logWarningMock).toHaveBeenCalledWith(
+      'Cache Service Url not found, unable to restore cache.',
+    );
+  });
+
+  it('should exit on invalid args', async () => {
+    // other calls do generate errors
+    const processExitMock = jest
+      .spyOn(process, 'exit')
+      // @ts-ignore
+      .mockImplementation(() => {});
+
+    // incomplete arguments
+    await cache.run();
+    await cache.run('save');
+
+    // bad arguments
+    await cache.run('save', 'unknown-cache');
+    await cache.run('unknown-action', 'unknown-cache');
+
+    setInputs({
+      [InputName.Caches]: 'non-existent',
+    });
+    await cache.run('save', 'npm');
+
+    expect(processExitMock).toHaveBeenCalledTimes(5);
+  });
+});

.github/actions/cached-dependencies/__tests__/fixtures/bashlib.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+default-setup-command() {
+  print-cachescript-path
+}

.github/actions/cached-dependencies/__tests__/fixtures/caches.ts

@@ -0,0 +1,14 @@
+/**
+ * Example cache config.
+ */
+export const npmHashFiles = ['.*ignore'];
+export const npmExpectedHash =
+  '13ed29a1c7ec906e7dcb20626957ebfcd3f0f2174bd2685a012105792bf1ff55';
+
+export default {
+  npm: {
+    path: [`~/.npm`],
+    hashFiles: npmHashFiles,
+    restoreKeys: 'node-npm-',
+  },
+};

.github/actions/cached-dependencies/__tests__/setup.test.ts

@@ -0,0 +1,101 @@
+/**
+ * Test default runner.
+ */
+import { setInputs } from '../src/utils/inputs';
+import { InputName, DefaultInputs } from '../src/constants';
+import * as setup from '../src/setup';
+import path from 'path';
+
+const extraBashlib = path.resolve(__dirname, './fixtures/bashlib.sh');
+
+describe('setup runner', () => {
+  // don't actually run the bash script
+  const runCommandMock = jest.spyOn(setup, 'runCommand');
+
+  it('should allow custom bashlib', async () => {
+    setInputs({
+      [InputName.Bashlib]: extraBashlib,
+    });
+    await setup.run();
+    expect(runCommandMock).toHaveBeenCalledTimes(1);
+    expect(runCommandMock).toHaveBeenCalledWith(
+      DefaultInputs[InputName.Run],
+      extraBashlib,
+    );
+  });
+
+  it('should allow inline bash overrides', async () => {
+    const processExitMock = jest
+      .spyOn(process, 'exit')
+      // @ts-ignore
+      .mockImplementation(() => {});
+
+    setInputs({
+      [InputName.Bashlib]: '',
+      [InputName.Parallel]: 'false',
+      [InputName.Run]: `
+        ${DefaultInputs[InputName.Run]}() {
+          echo "It works!"
+          exit 202
+        }
+        ${DefaultInputs[InputName.Run]}
+      `,
+    });
+    // allow the bash script to run for one test, but override the default
+    await setup.run();
+    expect(runCommandMock).toHaveBeenCalledTimes(1);
+    expect(processExitMock).toHaveBeenCalledTimes(1);
+    expect(processExitMock).toHaveBeenCalledWith(1);
+  });
+
+  it('should use run commands', async () => {
+    // don't run the commands when there is no overrides
+    runCommandMock.mockImplementation(async () => {});
+
+    setInputs({
+      [InputName.Bashlib]: 'non-existent',
+      [InputName.Run]: 'print-cachescript-path',
+    });
+
+    await setup.run();
+
+    expect(runCommandMock).toHaveBeenCalledTimes(1);
+    expect(runCommandMock).toHaveBeenCalledWith('print-cachescript-path', '');
+  });
+
+  it('should handle single-new-line parallel commands', async () => {
+    setInputs({
+      [InputName.Run]: `
+        test-command-1
+        test-command-2
+      `,
+      [InputName.Parallel]: 'true',
+    });
+
+    await setup.run();
+
+    expect(runCommandMock).toHaveBeenNthCalledWith(1, 'test-command-1', '');
+    expect(runCommandMock).toHaveBeenNthCalledWith(2, 'test-command-2', '');
+  });
+
+  it('should handle multi-new-line parallel commands', async () => {
+    setInputs({
+      [InputName.Run]: `
+        test-1-1
+        test-1-2
+
+        test-2
+      `,
+      [InputName.Parallel]: 'true',
+    });
+
+    await setup.run();
+
+    expect(runCommandMock).toHaveBeenNthCalledWith(
+      1,
+      'test-1-1\n        test-1-2',
+      '',
+    );
+    expect(runCommandMock).toHaveBeenNthCalledWith(2, 'test-2', '');
+  });
+});

.github/actions/cached-dependencies/__tests__/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "baseUrl": "./",
+    "outDir": "../build",
+    "noEmit": true,
+    "rootDir": "../"
+  },
+  "exclude": ["node_modules"]
+}