From acfd356f6e615e2db267821e4940de8e550c1181 Mon Sep 17 00:00:00 2001 From: Aparna Jyothi Date: Mon, 9 Jun 2025 12:26:21 +0530 Subject: [PATCH] Added logic to facilitate the Cache even it's in out side of root folder also --- __tests__/setup-python.test.ts | 92 ++++++++++++++++++++++++++++++++++ dist/setup/index.js | 25 ++++++++- src/setup-python.ts | 35 ++++++++++++- 3 files changed, 149 insertions(+), 3 deletions(-) create mode 100644 __tests__/setup-python.test.ts diff --git a/__tests__/setup-python.test.ts b/__tests__/setup-python.test.ts new file mode 100644 index 00000000..b454eeb2 --- /dev/null +++ b/__tests__/setup-python.test.ts @@ -0,0 +1,92 @@ +import * as core from '@actions/core'; +import * as fs from 'fs'; +import * as path from 'path'; +import {cacheDependencies} from '../src/setup-python'; +import {getCacheDistributor} from '../src/cache-distributions/cache-factory'; + +jest.mock('fs', () => { + const actualFs = jest.requireActual('fs'); + return { + ...actualFs, + copyFileSync: jest.fn(), + existsSync: jest.fn(), + promises: { + access: jest.fn(), + writeFile: jest.fn(), + appendFile: jest.fn() + } + }; +}); +jest.mock('@actions/core'); +jest.mock('../src/cache-distributions/cache-factory'); + +const mockedFs = fs as jest.Mocked; +const mockedCore = core as jest.Mocked; +const mockedGetCacheDistributor = getCacheDistributor as jest.Mock; + +describe('cacheDependencies', () => { + const mockRestoreCache = jest.fn(); + + beforeEach(() => { + jest.clearAllMocks(); + process.env.GITHUB_ACTION_PATH = '/github/action'; + process.env.GITHUB_WORKSPACE = '/github/workspace'; + + mockedCore.getInput.mockReturnValue('deps.lock'); + mockedFs.existsSync.mockReturnValue(true); + mockedFs.copyFileSync.mockImplementation(() => {}); + mockedGetCacheDistributor.mockReturnValue({restoreCache: mockRestoreCache}); + }); + + it('copies the dependency file and resolves the path', async () => { + await cacheDependencies('pip', '3.12'); + + const sourcePath = path.resolve('/github/action', 'deps.lock'); + const targetPath = path.resolve('/github/workspace', 'deps.lock'); + + expect(mockedFs.existsSync).toHaveBeenCalledWith(sourcePath); + expect(mockedFs.copyFileSync).toHaveBeenCalledWith(sourcePath, targetPath); + expect(mockedCore.info).toHaveBeenCalledWith( + `Copied ${sourcePath} to ${targetPath}` + ); + expect(mockedCore.info).toHaveBeenCalledWith( + `Resolved cache-dependency-path: deps.lock` + ); + expect(mockRestoreCache).toHaveBeenCalled(); + }); + + it('warns if the dependency file does not exist', async () => { + mockedFs.existsSync.mockReturnValue(false); + + await cacheDependencies('pip', '3.12'); + + expect(mockedCore.warning).toHaveBeenCalledWith( + expect.stringContaining('does not exist') + ); + expect(mockedFs.copyFileSync).not.toHaveBeenCalled(); + expect(mockRestoreCache).toHaveBeenCalled(); + }); + + it('warns if file copy fails', async () => { + mockedFs.copyFileSync.mockImplementation(() => { + throw new Error('copy failed'); + }); + + await cacheDependencies('pip', '3.12'); + + expect(mockedCore.warning).toHaveBeenCalledWith( + expect.stringContaining('Failed to copy file') + ); + expect(mockRestoreCache).toHaveBeenCalled(); + }); + + it('skips path logic if no input is provided', async () => { + mockedCore.getInput.mockReturnValue(''); + + await cacheDependencies('pip', '3.12'); + + expect(mockedFs.copyFileSync).not.toHaveBeenCalled(); + expect(mockedCore.warning).not.toHaveBeenCalled(); + expect(mockRestoreCache).toHaveBeenCalled(); + }); +}); diff --git a/dist/setup/index.js b/dist/setup/index.js index 4e3f2673..4da6c476 100644 --- a/dist/setup/index.js +++ b/dist/setup/index.js @@ -96905,6 +96905,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) { return (mod && mod.__esModule) ? mod : { "default": mod }; }; Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.cacheDependencies = void 0; const core = __importStar(__nccwpck_require__(7484)); const finder = __importStar(__nccwpck_require__(6843)); const finderPyPy = __importStar(__nccwpck_require__(2625)); @@ -96923,10 +96924,32 @@ function isGraalPyVersion(versionSpec) { function cacheDependencies(cache, pythonVersion) { return __awaiter(this, void 0, void 0, function* () { const cacheDependencyPath = core.getInput('cache-dependency-path') || undefined; - const cacheDistributor = (0, cache_factory_1.getCacheDistributor)(cache, pythonVersion, cacheDependencyPath); + let resolvedDependencyPath = undefined; + if (cacheDependencyPath) { + const actionPath = process.env.GITHUB_ACTION_PATH || ''; + const workspace = process.env.GITHUB_WORKSPACE || process.cwd(); + const sourcePath = path.resolve(actionPath, cacheDependencyPath); + const targetPath = path.resolve(workspace, path.basename(cacheDependencyPath)); + if (!fs_1.default.existsSync(sourcePath)) { + core.warning(`The resolved cache-dependency-path does not exist: ${sourcePath}`); + } + else { + try { + fs_1.default.copyFileSync(sourcePath, targetPath); + core.info(`Copied ${sourcePath} to ${targetPath}`); + } + catch (error) { + core.warning(`Failed to copy file from ${sourcePath} to ${targetPath}: ${error}`); + } + } + resolvedDependencyPath = path.relative(workspace, targetPath); + core.info(`Resolved cache-dependency-path: ${resolvedDependencyPath}`); + } + const cacheDistributor = (0, cache_factory_1.getCacheDistributor)(cache, pythonVersion, resolvedDependencyPath); yield cacheDistributor.restoreCache(); }); } +exports.cacheDependencies = cacheDependencies; function resolveVersionInputFromDefaultFile() { const couples = [ ['.python-version', utils_1.getVersionsInputFromPlainFile] diff --git a/src/setup-python.ts b/src/setup-python.ts index 5d585d73..e5a5c6e7 100644 --- a/src/setup-python.ts +++ b/src/setup-python.ts @@ -22,13 +22,44 @@ function isGraalPyVersion(versionSpec: string) { return versionSpec.startsWith('graalpy'); } -async function cacheDependencies(cache: string, pythonVersion: string) { +export async function cacheDependencies(cache: string, pythonVersion: string) { const cacheDependencyPath = core.getInput('cache-dependency-path') || undefined; + let resolvedDependencyPath: string | undefined = undefined; + + if (cacheDependencyPath) { + const actionPath = process.env.GITHUB_ACTION_PATH || ''; + const workspace = process.env.GITHUB_WORKSPACE || process.cwd(); + + const sourcePath = path.resolve(actionPath, cacheDependencyPath); + const targetPath = path.resolve( + workspace, + path.basename(cacheDependencyPath) + ); + + if (!fs.existsSync(sourcePath)) { + core.warning( + `The resolved cache-dependency-path does not exist: ${sourcePath}` + ); + } else { + try { + fs.copyFileSync(sourcePath, targetPath); + core.info(`Copied ${sourcePath} to ${targetPath}`); + } catch (error) { + core.warning( + `Failed to copy file from ${sourcePath} to ${targetPath}: ${error}` + ); + } + } + + resolvedDependencyPath = path.relative(workspace, targetPath); + core.info(`Resolved cache-dependency-path: ${resolvedDependencyPath}`); + } + const cacheDistributor = getCacheDistributor( cache, pythonVersion, - cacheDependencyPath + resolvedDependencyPath ); await cacheDistributor.restoreCache(); }