@ronaldphilipsen/local-action 0.0.0-stage → 7.0.1

package/__tests__/stubs/cache/internal/cacheUtils.test.ts

@@ -0,0 +1,109 @@
+import { jest } from '@jest/globals'
+import * as io from '../../../../__fixtures__/@actions/io.js'
+import * as fs from '../../../../__fixtures__/fs.js'
+
+jest.unstable_mockModule('@actions/io', () => io)
+jest.unstable_mockModule('fs', () => fs)
+
+// Import after mocking
+const {
+  getCacheFileName,
+  getCacheVersion,
+  createTempDirectory,
+  getArchiveFileSizeInBytes
+} = await import('../../../../src/stubs/cache/internal/cacheUtils.js')
+const { CacheFilename, CompressionMethod } =
+  await import('../../../../src/stubs/cache/internal/constants.js')
+
+describe('cache/internal/cacheUtils', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+
+    process.env.LOCAL_ACTION_WORKSPACE = '/tmp/workspace'
+
+    io.mkdirP.mockResolvedValue(undefined as never)
+    fs.statSync.mockReturnValue({ size: 1024 })
+  })
+
+  describe('getCacheFileName', () => {
+    it('Returns gzip filename for gzip compression', () => {
+      const result = getCacheFileName(CompressionMethod.Gzip)
+
+      expect(result).toBe(CacheFilename.Gzip)
+    })
+
+    it('Returns zstd filename for zstd compression', () => {
+      const result = getCacheFileName(CompressionMethod.Zstd)
+
+      expect(result).toBe(CacheFilename.Zstd)
+    })
+
+    it('Returns zstd filename for zstd without long compression', () => {
+      const result = getCacheFileName(CompressionMethod.ZstdWithoutLong)
+
+      expect(result).toBe(CacheFilename.Zstd)
+    })
+  })
+
+  describe('getCacheVersion', () => {
+    it('Generates cache version hash from paths', () => {
+      const paths = ['src/', 'dist/']
+
+      const result = getCacheVersion(paths)
+
+      // Should be a 64-character hex string (SHA-256)
+      expect(result).toMatch(/^[a-f0-9]{64}$/)
+    })
+
+    it('Includes compression method in cache version', () => {
+      const paths = ['src/']
+
+      const resultGzip = getCacheVersion(paths, CompressionMethod.Gzip)
+      const resultZstd = getCacheVersion(paths, CompressionMethod.Zstd)
+
+      expect(resultGzip).not.toBe(resultZstd)
+    })
+
+    it('Does not modify original paths array', () => {
+      const paths = ['src/', 'dist/']
+      const originalPaths = [...paths]
+
+      getCacheVersion(paths)
+
+      expect(paths).toEqual(originalPaths)
+    })
+  })
+
+  describe('createTempDirectory', () => {
+    beforeEach(() => {
+      process.env.LOCAL_ACTION_WORKSPACE = '/tmp/workspace'
+    })
+
+    it('Creates a temporary directory', async () => {
+      const tempDir = await createTempDirectory()
+
+      expect(tempDir).toMatch(
+        /^\/tmp\/workspace\/actions\/temp\/[a-f0-9-]{36}$/
+      )
+    })
+
+    it('Creates unique directories on multiple calls', async () => {
+      const tempDir1 = await createTempDirectory()
+      const tempDir2 = await createTempDirectory()
+
+      expect(tempDir1).not.toBe(tempDir2)
+    })
+  })
+
+  describe('getArchiveFileSizeInBytes', () => {
+    it('Returns the size of an archive file', () => {
+      const filePath = '/path/to/archive.tar.gz'
+      fs.statSync.mockReturnValue({ size: 2048 })
+
+      const size = getArchiveFileSizeInBytes(filePath)
+
+      expect(fs.statSync).toHaveBeenCalledWith(filePath)
+      expect(size).toBe(2048)
+    })
+  })
+})

package/__tests__/stubs/cache/internal/constants.test.ts

@@ -0,0 +1,81 @@
+import {
+  ArchiveToolType,
+  CacheFilename,
+  CacheFileSizeLimit,
+  CompressionMethod,
+  DefaultRetryAttempts,
+  DefaultRetryDelay,
+  GnuTarPathOnWindows,
+  ManifestFilename,
+  SocketTimeout,
+  SystemTarPathOnWindows,
+  TarFilename
+} from '../../../../src/stubs/cache/internal/constants.js'
+
+describe('cache/internal/constants', () => {
+  describe('CacheFilename', () => {
+    it('Has the correct values', () => {
+      expect(CacheFilename.Gzip).toBe('cache.tgz')
+      expect(CacheFilename.Zstd).toBe('cache.tzst')
+    })
+  })
+
+  describe('CompressionMethod', () => {
+    it('Has the correct values', () => {
+      expect(CompressionMethod.Gzip).toBe('gzip')
+      expect(CompressionMethod.ZstdWithoutLong).toBe('zstd-without-long')
+      expect(CompressionMethod.Zstd).toBe('zstd')
+    })
+  })
+
+  describe('ArchiveToolType', () => {
+    it('Has the correct values', () => {
+      expect(ArchiveToolType.GNU).toBe('gnu')
+      expect(ArchiveToolType.BSD).toBe('bsd')
+    })
+  })
+
+  describe('Default values', () => {
+    it('Has the correct default retry attempts', () => {
+      expect(DefaultRetryAttempts).toBe(2)
+    })
+
+    it('Has the correct default retry delay', () => {
+      expect(DefaultRetryDelay).toBe(5000)
+    })
+
+    it('Has the correct socket timeout', () => {
+      expect(SocketTimeout).toBe(5000)
+    })
+  })
+
+  describe('Windows tar paths', () => {
+    it('Has the correct GNU tar path', () => {
+      expect(GnuTarPathOnWindows).toBe(
+        `${process.env['PROGRAMFILES']}\\Git\\usr\\bin\\tar.exe`
+      )
+    })
+
+    it('Has the correct system tar path', () => {
+      expect(SystemTarPathOnWindows).toBe(
+        `${process.env['SYSTEMDRIVE']}\\Windows\\System32\\tar.exe`
+      )
+    })
+  })
+
+  describe('File names', () => {
+    it('Has the correct tar filename', () => {
+      expect(TarFilename).toBe('cache.tar')
+    })
+
+    it('Has the correct manifest filename', () => {
+      expect(ManifestFilename).toBe('manifest.txt')
+    })
+  })
+
+  describe('Cache file size limit', () => {
+    it('Has the correct size limit (10GiB)', () => {
+      expect(CacheFileSizeLimit).toBe(10 * Math.pow(1024, 3))
+    })
+  })
+})

package/__tests__/stubs/cache/internal/tar.test.ts

@@ -0,0 +1,129 @@
+import { jest } from '@jest/globals'
+import * as exec from '../../../../__fixtures__/@actions/exec.js'
+import * as io from '../../../../__fixtures__/@actions/io.js'
+import * as fs from '../../../../__fixtures__/fs.js'
+
+// Mock dependencies first
+const mockGetGnuTarPathOnWindows = jest.fn() as jest.MockedFunction<any>
+
+jest.unstable_mockModule('@actions/exec', () => exec)
+jest.unstable_mockModule('@actions/io', () => io)
+jest.unstable_mockModule('fs', () => fs)
+
+jest.unstable_mockModule(
+  '../../../../src/stubs/cache/internal/cacheUtils.js',
+  () => ({
+    getGnuTarPathOnWindows: mockGetGnuTarPathOnWindows,
+    getCacheFileName: jest.fn().mockReturnValue('cache.tgz')
+  })
+)
+
+// Import after mocking
+const { CompressionMethod } =
+  await import('../../../../src/stubs/cache/internal/constants.js')
+const { createTar, extractTar, listTar } =
+  await import('../../../../src/stubs/cache/internal/tar.js')
+
+describe('cache/internal/tar', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    process.env.LOCAL_ACTION_WORKSPACE = '/tmp/workspace'
+
+    // Default mock values
+    exec.exec.mockResolvedValue(0 as never)
+    fs.existsSync.mockReturnValue(true)
+    io.which.mockResolvedValue('/usr/bin/tar' as never)
+    mockGetGnuTarPathOnWindows.mockResolvedValue('/usr/bin/tar')
+    fs.writeFileSync.mockImplementation(() => {})
+  })
+
+  describe('listTar', () => {
+    it('Lists tar contents with gzip compression', async () => {
+      await listTar('/path/to/archive.tar.gz', CompressionMethod.Gzip)
+
+      expect(exec.exec).toHaveBeenCalledWith(
+        expect.stringContaining('tar'),
+        undefined,
+        expect.objectContaining({
+          env: expect.any(Object)
+        })
+      )
+    })
+  })
+
+  describe('extractTar', () => {
+    it('Extracts tar with gzip compression', async () => {
+      await extractTar('/path/to/archive.tar.gz', CompressionMethod.Gzip)
+
+      expect(exec.exec).toHaveBeenCalledWith(
+        expect.stringContaining('tar'),
+        undefined,
+        expect.objectContaining({
+          env: expect.any(Object)
+        })
+      )
+    })
+  })
+
+  describe('createTar', () => {
+    it('Creates tar with gzip compression', async () => {
+      const sourceDirectories = ['src/', 'dist/']
+      await createTar(
+        '/path/to/archive.tar.gz',
+        sourceDirectories,
+        CompressionMethod.Gzip
+      )
+
+      expect(fs.writeFileSync).toHaveBeenCalled()
+      expect(exec.exec).toHaveBeenCalledWith(
+        expect.stringContaining('tar'),
+        undefined,
+        expect.objectContaining({
+          cwd: expect.any(String),
+          env: expect.any(Object)
+        })
+      )
+    })
+
+    it('Creates tar with platform-specific args on macOS', async () => {
+      // Mock the process.platform to be darwin to test the platform-specific code path
+      const originalPlatform = Object.getOwnPropertyDescriptor(
+        process,
+        'platform'
+      )
+      Object.defineProperty(process, 'platform', {
+        value: 'darwin',
+        configurable: true
+      })
+
+      // Mock gtar being available to trigger GNU tar type
+      // The first call to which('gtar', false) should return the gtar path
+      // The subsequent calls to which('tar', true) can return regular tar
+      io.which.mockImplementation(((cmd: string) => {
+        if (cmd === 'gtar') {
+          return Promise.resolve('/usr/local/bin/gtar')
+        }
+        return Promise.resolve('/usr/bin/tar')
+      }) as never)
+
+      const sourceDirectories = ['src/']
+      await createTar(
+        '/path/to/archive.tar.gz',
+        sourceDirectories,
+        CompressionMethod.Gzip
+      )
+
+      expect(exec.exec).toHaveBeenCalledWith(
+        expect.stringContaining('--delay-directory-restore'),
+        undefined,
+        expect.objectContaining({
+          env: expect.any(Object)
+        })
+      )
+
+      // Restore original platform
+      if (originalPlatform)
+        Object.defineProperty(process, 'platform', originalPlatform)
+    })
+  })
+})