From 1d114a8000676bd873bb5a65c648583d5ddc070a Mon Sep 17 00:00:00 2001 From: Sankalp Kotewar <98868223+kotewar@users.noreply.github.com> Date: Tue, 20 Dec 2022 16:15:42 +0000 Subject: [PATCH] Save-only warning added --- .devcontainer/devcontainer.json | 2 +- __tests__/saveOnly.test.ts | 28 ++++++++++++++++++++++ dist/save-only/index.js | 41 ++++++++++++++++++++++++++++----- dist/save/index.js | 12 ++++++---- src/saveImpl.ts | 14 ++++++----- src/saveOnly.ts | 7 +++++- 6 files changed, 85 insertions(+), 19 deletions(-) diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json index ad830b5..801b750 100644 --- a/.devcontainer/devcontainer.json +++ b/.devcontainer/devcontainer.json @@ -6,7 +6,7 @@ // Use 'forwardPorts' to make a list of ports inside the container available locally. // "forwardPorts": [], // Use 'postCreateCommand' to run commands after the container is created. - "postCreateCommand": "npm install && npm run build" + "postCreateCommand": "npm install" // Configure tool-specific properties. // "customizations": {}, // Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root. diff --git a/__tests__/saveOnly.test.ts b/__tests__/saveOnly.test.ts index 2c2e0b8..44bd732 100644 --- a/__tests__/saveOnly.test.ts +++ b/__tests__/saveOnly.test.ts @@ -91,3 +91,31 @@ test("save with valid inputs uploads a cache", async () => { expect(failedMock).toHaveBeenCalledTimes(0); }); + +test("save failing logs the warning message", async () => { + const warningMock = jest.spyOn(core, "warning"); + + const primaryKey = "Linux-node-bb828da54c148048dd17899ba9fda624811cfb43"; + + const inputPath = "node_modules"; + testUtils.setInput(Inputs.Key, primaryKey); + testUtils.setInput(Inputs.Path, inputPath); + testUtils.setInput(Inputs.UploadChunkSize, "4000000"); + + const cacheId = -1; + const saveCacheMock = jest + .spyOn(cache, "saveCache") + .mockImplementationOnce(() => { + return Promise.resolve(cacheId); + }); + + await run(); + + expect(saveCacheMock).toHaveBeenCalledTimes(1); + expect(saveCacheMock).toHaveBeenCalledWith([inputPath], primaryKey, { + uploadChunkSize: 4000000 + }); + + expect(warningMock).toHaveBeenCalledTimes(1); + expect(warningMock).toHaveBeenCalledWith("Cache save failed."); +}); diff --git a/dist/save-only/index.js b/dist/save-only/index.js index 42f8457..3f87a6f 100644 --- a/dist/save-only/index.js +++ b/dist/save-only/index.js @@ -1043,6 +1043,29 @@ class ExecState extends events.EventEmitter { "use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } return new (P || (P = Promise))(function (resolve, reject) { @@ -1056,11 +1079,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) { return (mod && mod.__esModule) ? mod : { "default": mod }; }; Object.defineProperty(exports, "__esModule", { value: true }); +const core = __importStar(__webpack_require__(470)); const saveImpl_1 = __importDefault(__webpack_require__(471)); const stateProvider_1 = __webpack_require__(309); function run() { return __awaiter(this, void 0, void 0, function* () { - yield (0, saveImpl_1.default)(new stateProvider_1.NullStateProvider()); + const cacheId = yield (0, saveImpl_1.default)(new stateProvider_1.NullStateProvider()); + if (cacheId === -1) { + core.warning(`Cache save failed.`); + } }); } run(); @@ -41092,13 +41119,14 @@ const utils = __importStar(__webpack_require__(443)); process.on("uncaughtException", e => utils.logWarning(e.message)); function saveImpl(stateProvider) { return __awaiter(this, void 0, void 0, function* () { + let cacheId; try { if (!utils.isCacheFeatureAvailable()) { - return; + return 0; } if (!utils.isValidEvent()) { utils.logWarning(`Event Validation Error: The event type ${process.env[constants_1.Events.Key]} is not supported because it's not tied to a branch or tag ref.`); - return; + return 0; } // If restore has stored a primary key in state, reuse that // Else re-evaluate from inputs @@ -41106,19 +41134,19 @@ function saveImpl(stateProvider) { core.getInput(constants_1.Inputs.Key); if (!primaryKey) { utils.logWarning(`Key is not specified.`); - return; + return 0; } // If matched restore key is same as primary key, then do not save cache // NO-OP in case of SaveOnly action const restoredKey = stateProvider.getCacheState(); if (utils.isExactKeyMatch(primaryKey, restoredKey)) { core.info(`Cache hit occurred on the primary key ${primaryKey}, not saving cache.`); - return; + return 0; } const cachePaths = utils.getInputAsArray(constants_1.Inputs.Path, { required: true }); - const cacheId = yield cache.saveCache(cachePaths, primaryKey, { + cacheId = yield cache.saveCache(cachePaths, primaryKey, { uploadChunkSize: utils.getInputAsInt(constants_1.Inputs.UploadChunkSize) }); if (cacheId != -1) { @@ -41128,6 +41156,7 @@ function saveImpl(stateProvider) { catch (error) { utils.logWarning(error.message); } + return cacheId; }); } exports.default = saveImpl; diff --git a/dist/save/index.js b/dist/save/index.js index d5c5f68..5870eb4 100644 --- a/dist/save/index.js +++ b/dist/save/index.js @@ -41063,13 +41063,14 @@ const utils = __importStar(__webpack_require__(443)); process.on("uncaughtException", e => utils.logWarning(e.message)); function saveImpl(stateProvider) { return __awaiter(this, void 0, void 0, function* () { + let cacheId; try { if (!utils.isCacheFeatureAvailable()) { - return; + return 0; } if (!utils.isValidEvent()) { utils.logWarning(`Event Validation Error: The event type ${process.env[constants_1.Events.Key]} is not supported because it's not tied to a branch or tag ref.`); - return; + return 0; } // If restore has stored a primary key in state, reuse that // Else re-evaluate from inputs @@ -41077,19 +41078,19 @@ function saveImpl(stateProvider) { core.getInput(constants_1.Inputs.Key); if (!primaryKey) { utils.logWarning(`Key is not specified.`); - return; + return 0; } // If matched restore key is same as primary key, then do not save cache // NO-OP in case of SaveOnly action const restoredKey = stateProvider.getCacheState(); if (utils.isExactKeyMatch(primaryKey, restoredKey)) { core.info(`Cache hit occurred on the primary key ${primaryKey}, not saving cache.`); - return; + return 0; } const cachePaths = utils.getInputAsArray(constants_1.Inputs.Path, { required: true }); - const cacheId = yield cache.saveCache(cachePaths, primaryKey, { + cacheId = yield cache.saveCache(cachePaths, primaryKey, { uploadChunkSize: utils.getInputAsInt(constants_1.Inputs.UploadChunkSize) }); if (cacheId != -1) { @@ -41099,6 +41100,7 @@ function saveImpl(stateProvider) { catch (error) { utils.logWarning(error.message); } + return cacheId; }); } exports.default = saveImpl; diff --git a/src/saveImpl.ts b/src/saveImpl.ts index 1f0d366..9f86e52 100644 --- a/src/saveImpl.ts +++ b/src/saveImpl.ts @@ -10,10 +10,11 @@ import * as utils from "./utils/actionUtils"; // throw an uncaught exception. Instead of failing this action, just warn. process.on("uncaughtException", e => utils.logWarning(e.message)); -async function saveImpl(stateProvider: IStateProvider): Promise { +async function saveImpl(stateProvider: IStateProvider): Promise { + let cacheId; try { if (!utils.isCacheFeatureAvailable()) { - return; + return 0; } if (!utils.isValidEvent()) { @@ -22,7 +23,7 @@ async function saveImpl(stateProvider: IStateProvider): Promise { process.env[Events.Key] } is not supported because it's not tied to a branch or tag ref.` ); - return; + return 0; } // If restore has stored a primary key in state, reuse that @@ -33,7 +34,7 @@ async function saveImpl(stateProvider: IStateProvider): Promise { if (!primaryKey) { utils.logWarning(`Key is not specified.`); - return; + return 0; } // If matched restore key is same as primary key, then do not save cache @@ -44,14 +45,14 @@ async function saveImpl(stateProvider: IStateProvider): Promise { core.info( `Cache hit occurred on the primary key ${primaryKey}, not saving cache.` ); - return; + return 0; } const cachePaths = utils.getInputAsArray(Inputs.Path, { required: true }); - const cacheId = await cache.saveCache(cachePaths, primaryKey, { + cacheId = await cache.saveCache(cachePaths, primaryKey, { uploadChunkSize: utils.getInputAsInt(Inputs.UploadChunkSize) }); @@ -61,6 +62,7 @@ async function saveImpl(stateProvider: IStateProvider): Promise { } catch (error: unknown) { utils.logWarning((error as Error).message); } + return cacheId; } export default saveImpl; diff --git a/src/saveOnly.ts b/src/saveOnly.ts index e028d0e..bdc3f77 100644 --- a/src/saveOnly.ts +++ b/src/saveOnly.ts @@ -1,8 +1,13 @@ +import * as core from "@actions/core"; + import saveImpl from "./saveImpl"; import { NullStateProvider } from "./stateProvider"; async function run(): Promise { - await saveImpl(new NullStateProvider()); + const cacheId = await saveImpl(new NullStateProvider()); + if (cacheId === -1) { + core.warning(`Cache save failed.`); + } } run();