Download packages/cli/src/config/extensions/github.test.ts from SaylorTwift/gemini-cli: direct link, hf CLI and curl.
- Browser
- Download file 21.5 kB
-
https://huggingface.co/SaylorTwift/gemini-cli/resolve/main/packages/cli/src/config/extensions/github.test.ts
- Command line
-
hf download hf://SaylorTwift/gemini-cli/packages/cli/src/config/extensions/github.test.ts
-
curl -L -o github.test.ts https://huggingface.co/SaylorTwift/gemini-cli/resolve/main/packages/cli/src/config/extensions/github.test.ts
21.5 kB
| /** | |
| * @license | |
| * Copyright 2025 Google LLC | |
| * SPDX-License-Identifier: Apache-2.0 | |
| */ | |
| import { describe, it, expect, vi, beforeEach } from 'vitest'; | |
| import { | |
| cloneFromGit, | |
| tryParseGithubUrl, | |
| fetchReleaseFromGithub, | |
| checkForExtensionUpdate, | |
| downloadFromGitHubRelease, | |
| findReleaseAsset, | |
| downloadFile, | |
| extractFile, | |
| } from './github.js'; | |
| import { simpleGit, type SimpleGit } from 'simple-git'; | |
| import { ExtensionUpdateState } from '../../ui/state/extensions.js'; | |
| import * as os from 'node:os'; | |
| import * as fs from 'node:fs'; | |
| import * as https from 'node:https'; | |
| import * as tar from 'tar'; | |
| import * as extract from 'extract-zip'; | |
| import type { ExtensionManager } from '../extension-manager.js'; | |
| import { fetchJson } from './github_fetch.js'; | |
| import { EventEmitter } from 'node:events'; | |
| import type { | |
| GeminiCLIExtension, | |
| ExtensionInstallMetadata, | |
| } from '@google/gemini-cli-core'; | |
| import type { ExtensionConfig } from '../extension.js'; | |
| vi.mock('@google/gemini-cli-core', async (importOriginal) => { | |
| const actual = | |
| await importOriginal<typeof import('@google/gemini-cli-core')>(); | |
| return { | |
| ...actual, | |
| Storage: { | |
| getGlobalSettingsPath: vi.fn().mockReturnValue('/mock/settings.json'), | |
| getGlobalGeminiDir: vi.fn().mockReturnValue('/mock/.gemini'), | |
| }, | |
| debugLogger: { | |
| error: vi.fn(), | |
| log: vi.fn(), | |
| warn: vi.fn(), | |
| }, | |
| }; | |
| }); | |
| vi.mock('simple-git'); | |
| vi.mock('node:os'); | |
| vi.mock('node:fs'); | |
| vi.mock('node:https'); | |
| vi.mock('tar'); | |
| vi.mock('extract-zip'); | |
| vi.mock('./github_fetch.js'); | |
| vi.mock('../extension-manager.js'); | |
| // Mock settings.ts to avoid top-level side effects if possible, or just rely on Storage mock | |
| vi.mock('../settings.js', () => ({ | |
| loadSettings: vi.fn(), | |
| USER_SETTINGS_PATH: '/mock/settings.json', | |
| })); | |
| describe('github.ts', () => { | |
| beforeEach(() => { | |
| vi.resetAllMocks(); | |
| }); | |
| describe('cloneFromGit', () => { | |
| let mockGit: { | |
| clone: ReturnType<typeof vi.fn>; | |
| getRemotes: ReturnType<typeof vi.fn>; | |
| fetch: ReturnType<typeof vi.fn>; | |
| checkout: ReturnType<typeof vi.fn>; | |
| listRemote: ReturnType<typeof vi.fn>; | |
| revparse: ReturnType<typeof vi.fn>; | |
| env: ReturnType<typeof vi.fn>; | |
| }; | |
| beforeEach(() => { | |
| mockGit = { | |
| clone: vi.fn(), | |
| getRemotes: vi.fn(), | |
| fetch: vi.fn(), | |
| checkout: vi.fn(), | |
| listRemote: vi.fn(), | |
| revparse: vi.fn(), | |
| env: vi.fn().mockReturnThis(), | |
| }; | |
| vi.mocked(simpleGit).mockReturnValue(mockGit as unknown as SimpleGit); | |
| }); | |
| it('should clone, fetch and checkout a repo', async () => { | |
| mockGit.getRemotes.mockResolvedValue([{ name: 'origin' }]); | |
| await cloneFromGit( | |
| { | |
| type: 'git', | |
| source: 'https://github.com/owner/repo.git', | |
| ref: 'v1.0.0', | |
| }, | |
| '/dest', | |
| ); | |
| expect(mockGit.clone).toHaveBeenCalledWith( | |
| 'https://github.com/owner/repo.git', | |
| './', | |
| ['--depth', '1'], | |
| ); | |
| expect(mockGit.fetch).toHaveBeenCalledWith('origin', 'v1.0.0'); | |
| expect(mockGit.checkout).toHaveBeenCalledWith('FETCH_HEAD'); | |
| }); | |
| it('should throw if no remotes found', async () => { | |
| mockGit.getRemotes.mockResolvedValue([]); | |
| await expect( | |
| cloneFromGit({ type: 'git', source: 'src' }, '/dest'), | |
| ).rejects.toThrow('Unable to find any remotes'); | |
| }); | |
| it('should throw on clone error', async () => { | |
| mockGit.clone.mockRejectedValue(new Error('Clone failed')); | |
| await expect( | |
| cloneFromGit({ type: 'git', source: 'src' }, '/dest'), | |
| ).rejects.toThrow('Failed to clone Git repository'); | |
| }); | |
| }); | |
| describe('tryParseGithubUrl', () => { | |
| it.each([ | |
| ['https://github.com/owner/repo', 'owner', 'repo'], | |
| ['https://github.com/owner/repo.git', 'owner', 'repo'], | |
| ['git@github.com:owner/repo.git', 'owner', 'repo'], | |
| ['owner/repo', 'owner', 'repo'], | |
| ])('should parse %s to %s/%s', (url, owner, repo) => { | |
| expect(tryParseGithubUrl(url)).toEqual({ owner, repo }); | |
| }); | |
| it.each([ | |
| 'https://gitlab.com/owner/repo', | |
| 'https://my-git-host.com/owner/group/repo', | |
| 'git@gitlab.com:some-group/some-project/some-repo.git', | |
| ])('should return null for non-GitHub URLs', (url) => { | |
| expect(tryParseGithubUrl(url)).toBeNull(); | |
| }); | |
| it('should throw for invalid formats', () => { | |
| expect(() => tryParseGithubUrl('invalid')).toThrow( | |
| 'Invalid GitHub repository source', | |
| ); | |
| }); | |
| }); | |
| describe('fetchReleaseFromGithub', () => { | |
| it('should fetch latest release if no ref provided', async () => { | |
| vi.mocked(fetchJson).mockResolvedValue({ tag_name: 'v1.0.0' }); | |
| await fetchReleaseFromGithub('owner', 'repo'); | |
| expect(fetchJson).toHaveBeenCalledWith( | |
| 'https://api.github.com/repos/owner/repo/releases/latest', | |
| ); | |
| }); | |
| it('should fetch specific ref if provided', async () => { | |
| vi.mocked(fetchJson).mockResolvedValue({ tag_name: 'v1.0.0' }); | |
| await fetchReleaseFromGithub('owner', 'repo', 'v1.0.0'); | |
| expect(fetchJson).toHaveBeenCalledWith( | |
| 'https://api.github.com/repos/owner/repo/releases/tags/v1.0.0', | |
| ); | |
| }); | |
| it('should handle pre-releases if allowed', async () => { | |
| vi.mocked(fetchJson).mockResolvedValueOnce([{ tag_name: 'v1.0.0-beta' }]); | |
| const result = await fetchReleaseFromGithub( | |
| 'owner', | |
| 'repo', | |
| undefined, | |
| true, | |
| ); | |
| expect(result).toEqual({ tag_name: 'v1.0.0-beta' }); | |
| }); | |
| it('should return null if no releases found', async () => { | |
| vi.mocked(fetchJson).mockResolvedValueOnce([]); | |
| const result = await fetchReleaseFromGithub( | |
| 'owner', | |
| 'repo', | |
| undefined, | |
| true, | |
| ); | |
| expect(result).toBeNull(); | |
| }); | |
| }); | |
| describe('checkForExtensionUpdate', () => { | |
| let mockExtensionManager: ExtensionManager; | |
| let mockGit: { | |
| getRemotes: ReturnType<typeof vi.fn>; | |
| listRemote: ReturnType<typeof vi.fn>; | |
| revparse: ReturnType<typeof vi.fn>; | |
| env: ReturnType<typeof vi.fn>; | |
| }; | |
| beforeEach(() => { | |
| mockExtensionManager = { | |
| loadExtensionConfig: vi.fn(), | |
| } as unknown as ExtensionManager; | |
| mockGit = { | |
| getRemotes: vi.fn(), | |
| listRemote: vi.fn(), | |
| revparse: vi.fn(), | |
| env: vi.fn().mockReturnThis(), | |
| }; | |
| vi.mocked(simpleGit).mockReturnValue(mockGit as unknown as SimpleGit); | |
| }); | |
| it('should return NOT_UPDATABLE for non-git/non-release extensions', async () => { | |
| vi.mocked(mockExtensionManager.loadExtensionConfig).mockReturnValue( | |
| Promise.resolve({ | |
| version: '1.0.0', | |
| } as unknown as ExtensionConfig), | |
| ); | |
| const linkExt = { | |
| installMetadata: { type: 'link' }, | |
| } as unknown as GeminiCLIExtension; | |
| expect(await checkForExtensionUpdate(linkExt, mockExtensionManager)).toBe( | |
| ExtensionUpdateState.NOT_UPDATABLE, | |
| ); | |
| }); | |
| it('should return UPDATE_AVAILABLE if git remote hash differs', async () => { | |
| mockGit.getRemotes.mockResolvedValue([ | |
| { name: 'origin', refs: { fetch: 'url' } }, | |
| ]); | |
| mockGit.listRemote.mockResolvedValue('remote-hash\tHEAD'); | |
| mockGit.revparse.mockResolvedValue('local-hash'); | |
| const ext = { | |
| path: '/path', | |
| installMetadata: { type: 'git', source: 'url' }, | |
| } as unknown as GeminiCLIExtension; | |
| expect(await checkForExtensionUpdate(ext, mockExtensionManager)).toBe( | |
| ExtensionUpdateState.UPDATE_AVAILABLE, | |
| ); | |
| }); | |
| it('should return UP_TO_DATE if git remote hash matches', async () => { | |
| mockGit.getRemotes.mockResolvedValue([ | |
| { name: 'origin', refs: { fetch: 'url' } }, | |
| ]); | |
| mockGit.listRemote.mockResolvedValue('hash\tHEAD'); | |
| mockGit.revparse.mockResolvedValue('hash'); | |
| const ext = { | |
| path: '/path', | |
| installMetadata: { type: 'git', source: 'url' }, | |
| } as unknown as GeminiCLIExtension; | |
| expect(await checkForExtensionUpdate(ext, mockExtensionManager)).toBe( | |
| ExtensionUpdateState.UP_TO_DATE, | |
| ); | |
| }); | |
| it('should return NOT_UPDATABLE if local extension config cannot be loaded', async () => { | |
| vi.mocked(mockExtensionManager.loadExtensionConfig).mockImplementation( | |
| async () => { | |
| throw new Error('Config not found'); | |
| }, | |
| ); | |
| const ext = { | |
| name: 'local-ext', | |
| version: '1.0.0', | |
| path: '/path/to/installed/ext', | |
| installMetadata: { type: 'local', source: '/path/to/source/ext' }, | |
| } as unknown as GeminiCLIExtension; | |
| expect(await checkForExtensionUpdate(ext, mockExtensionManager)).toBe( | |
| ExtensionUpdateState.NOT_UPDATABLE, | |
| ); | |
| }); | |
| it('should check migratedTo source if present and return UPDATE_AVAILABLE', async () => { | |
| mockGit.getRemotes.mockResolvedValue([ | |
| { name: 'origin', refs: { fetch: 'new-url' } }, | |
| ]); | |
| mockGit.listRemote.mockResolvedValue('hash\tHEAD'); | |
| mockGit.revparse.mockResolvedValue('hash'); | |
| const ext = { | |
| path: '/path', | |
| migratedTo: 'new-url', | |
| installMetadata: { type: 'git', source: 'old-url' }, | |
| } as unknown as GeminiCLIExtension; | |
| expect(await checkForExtensionUpdate(ext, mockExtensionManager)).toBe( | |
| ExtensionUpdateState.UPDATE_AVAILABLE, | |
| ); | |
| }); | |
| }); | |
| describe('downloadFromGitHubRelease', () => { | |
| it('should fail if no release data found', async () => { | |
| // Mock fetchJson to throw for latest release check | |
| vi.mocked(fetchJson).mockRejectedValue(new Error('Not found')); | |
| const result = await downloadFromGitHubRelease( | |
| { | |
| type: 'github-release', | |
| source: 'owner/repo', | |
| ref: 'v1', | |
| } as unknown as ExtensionInstallMetadata, | |
| '/dest', | |
| { owner: 'owner', repo: 'repo' }, | |
| ); | |
| expect(result.success).toBe(false); | |
| if (!result.success) { | |
| expect(result.failureReason).toBe('failed to fetch release data'); | |
| } | |
| }); | |
| it('should use correct headers for release assets', async () => { | |
| vi.mocked(fetchJson).mockResolvedValue({ | |
| tag_name: 'v1.0.0', | |
| assets: [{ name: 'asset.tar.gz', url: 'http://asset.url' }], | |
| }); | |
| vi.mocked(os.platform).mockReturnValue('linux'); | |
| vi.mocked(os.arch).mockReturnValue('x64'); | |
| // Mock https.get and fs.createWriteStream for downloadFile | |
| const mockReq = new EventEmitter(); | |
| const mockRes = | |
| new EventEmitter() as unknown as import('node:http').IncomingMessage; | |
| Object.assign(mockRes, { statusCode: 200, pipe: vi.fn() }); | |
| vi.mocked(https.get).mockImplementation((url, options, cb) => { | |
| if (typeof options === 'function') { | |
| cb = options; | |
| } | |
| if (cb) cb(mockRes); | |
| return mockReq as unknown as import('node:http').ClientRequest; | |
| }); | |
| const mockStream = new EventEmitter() as unknown as fs.WriteStream; | |
| Object.assign(mockStream, { close: vi.fn((cb) => cb && cb()) }); | |
| vi.mocked(fs.createWriteStream).mockReturnValue(mockStream); | |
| // Mock fs.promises.readdir to return empty array (no cleanup needed) | |
| vi.mocked(fs.promises.readdir).mockResolvedValue([]); | |
| // Mock fs.promises.unlink | |
| vi.mocked(fs.promises.unlink).mockResolvedValue(undefined); | |
| const promise = downloadFromGitHubRelease( | |
| { | |
| type: 'github-release', | |
| source: 'owner/repo', | |
| ref: 'v1.0.0', | |
| } as unknown as ExtensionInstallMetadata, | |
| '/dest', | |
| { owner: 'owner', repo: 'repo' }, | |
| ); | |
| // Wait for downloadFile to be called and stream to be created | |
| await vi.waitUntil( | |
| () => vi.mocked(fs.createWriteStream).mock.calls.length > 0, | |
| ); | |
| // Trigger stream events to complete download | |
| mockRes.emit('end'); | |
| mockStream.emit('finish'); | |
| await promise; | |
| expect(https.get).toHaveBeenCalledWith( | |
| 'http://asset.url', | |
| expect.objectContaining({ | |
| headers: expect.objectContaining({ | |
| Accept: 'application/octet-stream', | |
| }), | |
| }), | |
| expect.anything(), | |
| ); | |
| }); | |
| it('should use correct headers for source tarballs', async () => { | |
| vi.mocked(fetchJson).mockResolvedValue({ | |
| tag_name: 'v1.0.0', | |
| assets: [], | |
| tarball_url: 'http://tarball.url', | |
| }); | |
| // Mock https.get and fs.createWriteStream for downloadFile | |
| const mockReq = new EventEmitter(); | |
| const mockRes = | |
| new EventEmitter() as unknown as import('node:http').IncomingMessage; | |
| Object.assign(mockRes, { statusCode: 200, pipe: vi.fn() }); | |
| vi.mocked(https.get).mockImplementation((url, options, cb) => { | |
| if (typeof options === 'function') { | |
| cb = options; | |
| } | |
| if (cb) cb(mockRes); | |
| return mockReq as unknown as import('node:http').ClientRequest; | |
| }); | |
| const mockStream = new EventEmitter() as unknown as fs.WriteStream; | |
| Object.assign(mockStream, { close: vi.fn((cb) => cb && cb()) }); | |
| vi.mocked(fs.createWriteStream).mockReturnValue(mockStream); | |
| // Mock fs.promises.readdir to return empty array | |
| vi.mocked(fs.promises.readdir).mockResolvedValue([]); | |
| // Mock fs.promises.unlink | |
| vi.mocked(fs.promises.unlink).mockResolvedValue(undefined); | |
| const promise = downloadFromGitHubRelease( | |
| { | |
| type: 'github-release', | |
| source: 'owner/repo', | |
| ref: 'v1.0.0', | |
| } as unknown as ExtensionInstallMetadata, | |
| '/dest', | |
| { owner: 'owner', repo: 'repo' }, | |
| ); | |
| // Wait for downloadFile to be called and stream to be created | |
| await vi.waitUntil( | |
| () => vi.mocked(fs.createWriteStream).mock.calls.length > 0, | |
| ); | |
| // Trigger stream events to complete download | |
| mockRes.emit('end'); | |
| mockStream.emit('finish'); | |
| await promise; | |
| expect(https.get).toHaveBeenCalledWith( | |
| 'http://tarball.url', | |
| expect.objectContaining({ | |
| headers: expect.objectContaining({ | |
| Accept: 'application/vnd.github+json', | |
| }), | |
| }), | |
| expect.anything(), | |
| ); | |
| }); | |
| }); | |
| describe('findReleaseAsset', () => { | |
| it('should find platform/arch specific asset', () => { | |
| vi.mocked(os.platform).mockReturnValue('darwin'); | |
| vi.mocked(os.arch).mockReturnValue('arm64'); | |
| const assets = [ | |
| { name: 'darwin.arm64.tar.gz', url: 'url1' }, | |
| { name: 'linux.x64.tar.gz', url: 'url2' }, | |
| ]; | |
| expect(findReleaseAsset(assets)).toEqual(assets[0]); | |
| }); | |
| it('should find generic asset', () => { | |
| vi.mocked(os.platform).mockReturnValue('darwin'); | |
| const assets = [{ name: 'generic.tar.gz', url: 'url' }]; | |
| expect(findReleaseAsset(assets)).toEqual(assets[0]); | |
| }); | |
| }); | |
| describe('downloadFile', () => { | |
| it('should download file successfully', async () => { | |
| const mockReq = new EventEmitter(); | |
| const mockRes = | |
| new EventEmitter() as unknown as import('node:http').IncomingMessage; | |
| Object.assign(mockRes, { statusCode: 200, pipe: vi.fn() }); | |
| vi.mocked(https.get).mockImplementation((url, options, cb) => { | |
| if (typeof options === 'function') { | |
| cb = options; | |
| } | |
| if (cb) cb(mockRes); | |
| return mockReq as unknown as import('node:http').ClientRequest; | |
| }); | |
| const mockStream = new EventEmitter() as unknown as fs.WriteStream; | |
| Object.assign(mockStream, { close: vi.fn((cb) => cb && cb()) }); | |
| vi.mocked(fs.createWriteStream).mockReturnValue(mockStream); | |
| const promise = downloadFile('url', '/dest'); | |
| mockRes.emit('end'); | |
| mockStream.emit('finish'); | |
| await expect(promise).resolves.toBeUndefined(); | |
| }); | |
| it('should fail on non-200 status', async () => { | |
| const mockReq = new EventEmitter(); | |
| const mockRes = | |
| new EventEmitter() as unknown as import('node:http').IncomingMessage; | |
| Object.assign(mockRes, { statusCode: 404 }); | |
| vi.mocked(https.get).mockImplementation((url, options, cb) => { | |
| if (typeof options === 'function') { | |
| cb = options; | |
| } | |
| if (cb) cb(mockRes); | |
| return mockReq as unknown as import('node:http').ClientRequest; | |
| }); | |
| await expect(downloadFile('url', '/dest')).rejects.toThrow( | |
| 'Request failed with status code 404', | |
| ); | |
| }); | |
| it('should follow redirects', async () => { | |
| const mockReq = new EventEmitter(); | |
| const mockResRedirect = | |
| new EventEmitter() as unknown as import('node:http').IncomingMessage; | |
| Object.assign(mockResRedirect, { | |
| statusCode: 302, | |
| headers: { location: 'new-url' }, | |
| }); | |
| const mockResSuccess = | |
| new EventEmitter() as unknown as import('node:http').IncomingMessage; | |
| Object.assign(mockResSuccess, { statusCode: 200, pipe: vi.fn() }); | |
| vi.mocked(https.get) | |
| .mockImplementationOnce((url, options, cb) => { | |
| if (typeof options === 'function') cb = options; | |
| if (cb) cb(mockResRedirect); | |
| return mockReq as unknown as import('node:http').ClientRequest; | |
| }) | |
| .mockImplementationOnce((url, options, cb) => { | |
| if (typeof options === 'function') cb = options; | |
| if (cb) cb(mockResSuccess); | |
| return mockReq as unknown as import('node:http').ClientRequest; | |
| }); | |
| const mockStream = new EventEmitter() as unknown as fs.WriteStream; | |
| Object.assign(mockStream, { close: vi.fn((cb) => cb && cb()) }); | |
| vi.mocked(fs.createWriteStream).mockReturnValue(mockStream); | |
| const promise = downloadFile('url', '/dest'); | |
| mockResSuccess.emit('end'); | |
| mockStream.emit('finish'); | |
| await expect(promise).resolves.toBeUndefined(); | |
| expect(https.get).toHaveBeenCalledTimes(2); | |
| expect(https.get).toHaveBeenLastCalledWith( | |
| 'new-url', | |
| expect.anything(), | |
| expect.anything(), | |
| ); | |
| }); | |
| it('should fail after too many redirects', async () => { | |
| const mockReq = new EventEmitter(); | |
| const mockResRedirect = | |
| new EventEmitter() as unknown as import('node:http').IncomingMessage; | |
| Object.assign(mockResRedirect, { | |
| statusCode: 302, | |
| headers: { location: 'new-url' }, | |
| }); | |
| vi.mocked(https.get).mockImplementation((url, options, cb) => { | |
| if (typeof options === 'function') cb = options; | |
| if (cb) cb(mockResRedirect); | |
| return mockReq as unknown as import('node:http').ClientRequest; | |
| }); | |
| await expect(downloadFile('url', '/dest')).rejects.toThrow( | |
| 'Too many redirects', | |
| ); | |
| }, 10000); // Increase timeout for this test if needed, though with mocks it should be fast | |
| it('should fail if redirect location is missing', async () => { | |
| const mockReq = new EventEmitter(); | |
| const mockResRedirect = | |
| new EventEmitter() as unknown as import('node:http').IncomingMessage; | |
| Object.assign(mockResRedirect, { | |
| statusCode: 302, | |
| headers: {}, // No location | |
| }); | |
| vi.mocked(https.get).mockImplementation((url, options, cb) => { | |
| if (typeof options === 'function') cb = options; | |
| if (cb) cb(mockResRedirect); | |
| return mockReq as unknown as import('node:http').ClientRequest; | |
| }); | |
| await expect(downloadFile('url', '/dest')).rejects.toThrow( | |
| 'Redirect response missing Location header', | |
| ); | |
| }); | |
| it('should pass custom headers', async () => { | |
| const mockReq = new EventEmitter(); | |
| const mockRes = | |
| new EventEmitter() as unknown as import('node:http').IncomingMessage; | |
| Object.assign(mockRes, { statusCode: 200, pipe: vi.fn() }); | |
| vi.mocked(https.get).mockImplementation((url, options, cb) => { | |
| if (typeof options === 'function') cb = options; | |
| if (cb) cb(mockRes); | |
| return mockReq as unknown as import('node:http').ClientRequest; | |
| }); | |
| const mockStream = new EventEmitter() as unknown as fs.WriteStream; | |
| Object.assign(mockStream, { close: vi.fn((cb) => cb && cb()) }); | |
| vi.mocked(fs.createWriteStream).mockReturnValue(mockStream); | |
| const promise = downloadFile('url', '/dest', { | |
| headers: { 'X-Custom': 'value' }, | |
| }); | |
| mockRes.emit('end'); | |
| mockStream.emit('finish'); | |
| await expect(promise).resolves.toBeUndefined(); | |
| expect(https.get).toHaveBeenCalledWith( | |
| 'url', | |
| expect.objectContaining({ | |
| headers: expect.objectContaining({ 'X-Custom': 'value' }), | |
| }), | |
| expect.anything(), | |
| ); | |
| }); | |
| }); | |
| describe('extractFile', () => { | |
| it('should extract tar.gz using tar', async () => { | |
| await extractFile('file.tar.gz', '/dest'); | |
| expect(tar.x).toHaveBeenCalled(); | |
| }); | |
| it('should extract zip using extract-zip', async () => { | |
| vi.mocked(extract.default || extract).mockResolvedValue(undefined); | |
| await extractFile('file.zip', '/dest'); | |
| // Check if extract was called. Note: extract-zip export might be default or named depending on mock | |
| }); | |
| it('should throw for unsupported extensions', async () => { | |
| await expect(extractFile('file.txt', '/dest')).rejects.toThrow( | |
| 'Unsupported file extension', | |
| ); | |
| }); | |
| }); | |
| }); | |