Initial commit to create @actions/cache package

Author: Aiqiao Yan

README.md

@@ -82,6 +82,15 @@ $ npm install @actions/artifact --save
 ```
 <br/>
 
+:dart: [@actions/cache](packages/cache) 
+
+Provides functions to interact with actions cache. Read more [here](packages/cache)
+
+```bash
+$ npm install @actions/artifact --save
+```
+<br/>
+
 ## Creating an Action with the Toolkit
 
 :question: [Choosing an action type](docs/action-types.md)

packages/cache/CONTRIBUTIONS.md

@@ -0,0 +1 @@
+# `@actions/cache`

packages/cache/README.md

@@ -0,0 +1,5 @@
+# @actions/cache Releases
+
+### 0.0.0
+
+- Initial release

packages/cache/RELEASES.md

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

packages/cache/__tests__/__fixtures__/helloWorld.txt

@@ -0,0 +1,28 @@
+import {getCacheVersion} from '../src/internal/cacheHttpClient'
+import {CompressionMethod} from '../src/internal/constants'
+
+test('getCacheVersion with path input and compression method undefined returns version', async () => {
+  const inputPath = 'node_modules'
+  const result = getCacheVersion(inputPath)
+  expect(result).toEqual(
+    'b3e0c6cb5ecf32614eeb2997d905b9c297046d7cbf69062698f25b14b4cb0985'
+  )
+})
+
+test('getCacheVersion with zstd compression returns version', async () => {
+  const inputPath = 'node_modules'
+  const result = getCacheVersion(inputPath, CompressionMethod.Zstd)
+
+  expect(result).toEqual(
+    '273877e14fd65d270b87a198edbfa2db5a43de567c9a548d2a2505b408befe24'
+  )
+})
+
+test('getCacheVersion with gzip compression does not change vesion', async () => {
+  const inputPath = 'node_modules'
+  const result = getCacheVersion(inputPath, CompressionMethod.Gzip)
+
+  expect(result).toEqual(
+    'b3e0c6cb5ecf32614eeb2997d905b9c297046d7cbf69062698f25b14b4cb0985'
+  )
+})

packages/cache/__tests__/cacheHttpClient.test.ts

@@ -0,0 +1,177 @@
+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 {v4 as uuidV4} from 'uuid'
+import * as cacheUtils from '../src/internal/cacheUtils'
+
+jest.mock('@actions/core')
+jest.mock('os')
+
+function getTempDir(): string {
+  return path.join(__dirname, '_temp', 'cacheUtils')
+}
+
+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 = cacheUtils.getArchiveFileSize(filePath)
+
+  expect(size).toBe(11)
+})
+
+test('logWarning logs a message with a warning prefix', () => {
+  const message = 'A warning occurred.'
+
+  const infoMock = jest.spyOn(core, 'info')
+
+  cacheUtils.logWarning(message)
+
+  expect(infoMock).toHaveBeenCalledWith(`[warning]${message}`)
+})
+
+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 cacheUtils.resolvePaths([filePath])
+
+    const expectedPath = [filePath]
+    expect(resolvedPath).toStrictEqual(expectedPath)
+  } finally {
+    process.chdir(originalCwd)
+  }
+})
+
+test('resolvePaths with ~ in path', async () => {
+  const cacheDir = uuidV4()
+  const filePath = `~/${cacheDir}`
+  // Create the following layout:
+  //   ~/uuid
+  //   ~/uuid/file.txt
+
+  const homedir = jest.requireActual('os').homedir()
+  const homedirMock = jest.spyOn(os, 'homedir')
+  homedirMock.mockReturnValue(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 cacheUtils.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.mockReturnValue('')
+
+  await expect(cacheUtils.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 cacheUtils.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 cacheUtils.resolvePaths(patterns)
+
+    const expectedPath: string[] = []
+    expect(resolvedPath).toStrictEqual(expectedPath)
+  } finally {
+    process.chdir(originalCwd)
+  }
+})
+
+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 cacheUtils.unlinkFile(testFile)
+
+  // This should throw as testFile should not exist
+  await expect(fs.stat(testFile)).rejects.toThrow()
+
+  await fs.rmdir(testDirectory)
+})