mirror of
https://github.com/actions/checkout.git
synced 2026-09-16 02:57:17 +08:00
81a936fd3c
Adds a `quiet` input (default: false) that passes `--quiet` to the git commands that fetch and check out the repository: `fetch`, `checkout`, `checkout --detach`, and `submodule update`. With `fetch-depth: 0` the refspec covers every branch and tag, so git prints a `From <url>` line plus one `* [new branch]` / `* [new tag]` line per ref. On a ref-heavy repository that summary is the bulk of the checkout log, and `show-progress: false` does not remove it -- that input only ever controlled `--progress`. `--quiet` and `--progress` drive different output and compose rather than conflict: `--progress` forces the transfer/update meter, while `--quiet` drops the ref summary and other informational messages. `checkout` keeps its `--progress` when quiet, so a slow checkout still reports progress. `git lfs fetch` has no `--quiet` flag, so LFS output is unchanged. Fixes #2409
781 lines
19 KiB
TypeScript
781 lines
19 KiB
TypeScript
import {
|
|
jest,
|
|
describe,
|
|
it,
|
|
expect,
|
|
beforeAll,
|
|
beforeEach,
|
|
afterEach,
|
|
afterAll
|
|
} from '@jest/globals'
|
|
|
|
// Mock @actions/exec
|
|
const mockExec = jest.fn()
|
|
jest.unstable_mockModule('@actions/exec', () => ({
|
|
exec: mockExec
|
|
}))
|
|
|
|
// Mock fs-helper
|
|
const mockFileExistsSync = jest.fn()
|
|
const mockDirectoryExistsSync = jest.fn()
|
|
jest.unstable_mockModule('../src/fs-helper.js', () => ({
|
|
fileExistsSync: mockFileExistsSync,
|
|
directoryExistsSync: mockDirectoryExistsSync
|
|
}))
|
|
|
|
// Dynamic imports after mocking
|
|
const commandManager = await import('../src/git-command-manager.js')
|
|
type IGitCommandManager =
|
|
import('../src/git-command-manager.js').IGitCommandManager
|
|
|
|
let git: IGitCommandManager
|
|
|
|
describe('git-auth-helper tests', () => {
|
|
beforeAll(async () => {})
|
|
|
|
beforeEach(async () => {
|
|
mockFileExistsSync.mockReset()
|
|
mockDirectoryExistsSync.mockReset()
|
|
})
|
|
|
|
afterEach(() => {
|
|
jest.clearAllMocks()
|
|
})
|
|
|
|
afterAll(() => {})
|
|
|
|
it('branch list matches', async () => {
|
|
mockExec.mockImplementation((path: any, args: any, options: any) => {
|
|
console.log(args, options.listeners.stdout)
|
|
|
|
if (args.includes('version')) {
|
|
options.listeners.stdout(Buffer.from('2.18'))
|
|
return 0
|
|
}
|
|
|
|
if (args.includes('rev-parse')) {
|
|
options.listeners.stdline(Buffer.from('refs/heads/foo'))
|
|
options.listeners.stdline(Buffer.from('refs/heads/bar'))
|
|
return 0
|
|
}
|
|
|
|
return 1
|
|
})
|
|
// exec.exec is already mockExec
|
|
const workingDirectory = 'test'
|
|
const lfs = false
|
|
const doSparseCheckout = false
|
|
git = await commandManager.createCommandManager(
|
|
workingDirectory,
|
|
lfs,
|
|
doSparseCheckout
|
|
)
|
|
|
|
let branches = await git.branchList(false)
|
|
|
|
expect(branches).toHaveLength(2)
|
|
expect(branches.sort()).toEqual(['foo', 'bar'].sort())
|
|
})
|
|
|
|
it('ambiguous ref name output is captured', async () => {
|
|
mockExec.mockImplementation((path: any, args: any, options: any) => {
|
|
console.log(args, options.listeners.stdout)
|
|
|
|
if (args.includes('version')) {
|
|
options.listeners.stdout(Buffer.from('2.18'))
|
|
return 0
|
|
}
|
|
|
|
if (args.includes('rev-parse')) {
|
|
options.listeners.stdline(Buffer.from('refs/heads/foo'))
|
|
// If refs/tags/v1 and refs/heads/tags/v1 existed on this repository
|
|
options.listeners.errline(
|
|
Buffer.from("error: refname 'tags/v1' is ambiguous")
|
|
)
|
|
return 0
|
|
}
|
|
|
|
return 1
|
|
})
|
|
// exec.exec is already mockExec
|
|
const workingDirectory = 'test'
|
|
const lfs = false
|
|
const doSparseCheckout = false
|
|
git = await commandManager.createCommandManager(
|
|
workingDirectory,
|
|
lfs,
|
|
doSparseCheckout
|
|
)
|
|
|
|
let branches = await git.branchList(false)
|
|
|
|
expect(branches).toHaveLength(1)
|
|
expect(branches.sort()).toEqual(['foo'].sort())
|
|
})
|
|
})
|
|
|
|
describe('Test fetchDepth and fetchTags options', () => {
|
|
beforeEach(async () => {
|
|
mockFileExistsSync.mockReset()
|
|
mockDirectoryExistsSync.mockReset()
|
|
mockExec.mockImplementation((path: any, args: any, options: any) => {
|
|
console.log(args, options.listeners.stdout)
|
|
|
|
if (args.includes('version')) {
|
|
options.listeners.stdout(Buffer.from('2.18'))
|
|
}
|
|
|
|
return 0
|
|
})
|
|
})
|
|
|
|
afterEach(() => {
|
|
jest.clearAllMocks()
|
|
})
|
|
|
|
it('should call execGit with the correct arguments when fetchDepth is 0', async () => {
|
|
// exec.exec is already mockExec
|
|
const workingDirectory = 'test'
|
|
const lfs = false
|
|
const doSparseCheckout = false
|
|
git = await commandManager.createCommandManager(
|
|
workingDirectory,
|
|
lfs,
|
|
doSparseCheckout
|
|
)
|
|
|
|
const refSpec = ['refspec1', 'refspec2']
|
|
const options = {
|
|
filter: 'filterValue',
|
|
fetchDepth: 0
|
|
}
|
|
|
|
await git.fetch(refSpec, options)
|
|
|
|
expect(mockExec).toHaveBeenCalledWith(
|
|
expect.any(String),
|
|
[
|
|
'-c',
|
|
'protocol.version=2',
|
|
'fetch',
|
|
'--no-tags',
|
|
'--prune',
|
|
'--no-recurse-submodules',
|
|
'--filter=filterValue',
|
|
'origin',
|
|
'refspec1',
|
|
'refspec2'
|
|
],
|
|
expect.any(Object)
|
|
)
|
|
})
|
|
|
|
it('should call execGit with the correct arguments when fetchDepth is 0 and refSpec includes tags', async () => {
|
|
// exec.exec is already mockExec
|
|
|
|
const workingDirectory = 'test'
|
|
const lfs = false
|
|
const doSparseCheckout = false
|
|
git = await commandManager.createCommandManager(
|
|
workingDirectory,
|
|
lfs,
|
|
doSparseCheckout
|
|
)
|
|
const refSpec = ['refspec1', 'refspec2', '+refs/tags/*:refs/tags/*']
|
|
const options = {
|
|
filter: 'filterValue',
|
|
fetchDepth: 0
|
|
}
|
|
|
|
await git.fetch(refSpec, options)
|
|
|
|
expect(mockExec).toHaveBeenCalledWith(
|
|
expect.any(String),
|
|
[
|
|
'-c',
|
|
'protocol.version=2',
|
|
'fetch',
|
|
'--no-tags',
|
|
'--prune',
|
|
'--no-recurse-submodules',
|
|
'--filter=filterValue',
|
|
'origin',
|
|
'refspec1',
|
|
'refspec2',
|
|
'+refs/tags/*:refs/tags/*'
|
|
],
|
|
expect.any(Object)
|
|
)
|
|
})
|
|
|
|
it('should call execGit with the correct arguments when fetchDepth is 1', async () => {
|
|
// exec.exec is already mockExec
|
|
|
|
const workingDirectory = 'test'
|
|
const lfs = false
|
|
const doSparseCheckout = false
|
|
git = await commandManager.createCommandManager(
|
|
workingDirectory,
|
|
lfs,
|
|
doSparseCheckout
|
|
)
|
|
const refSpec = ['refspec1', 'refspec2']
|
|
const options = {
|
|
filter: 'filterValue',
|
|
fetchDepth: 1
|
|
}
|
|
|
|
await git.fetch(refSpec, options)
|
|
|
|
expect(mockExec).toHaveBeenCalledWith(
|
|
expect.any(String),
|
|
[
|
|
'-c',
|
|
'protocol.version=2',
|
|
'fetch',
|
|
'--no-tags',
|
|
'--prune',
|
|
'--no-recurse-submodules',
|
|
'--filter=filterValue',
|
|
'--depth=1',
|
|
'origin',
|
|
'refspec1',
|
|
'refspec2'
|
|
],
|
|
expect.any(Object)
|
|
)
|
|
})
|
|
|
|
it('should call execGit with the correct arguments when fetchDepth is 1 and refSpec includes tags', async () => {
|
|
// exec.exec is already mockExec
|
|
|
|
const workingDirectory = 'test'
|
|
const lfs = false
|
|
const doSparseCheckout = false
|
|
git = await commandManager.createCommandManager(
|
|
workingDirectory,
|
|
lfs,
|
|
doSparseCheckout
|
|
)
|
|
const refSpec = ['refspec1', 'refspec2', '+refs/tags/*:refs/tags/*']
|
|
const options = {
|
|
filter: 'filterValue',
|
|
fetchDepth: 1
|
|
}
|
|
|
|
await git.fetch(refSpec, options)
|
|
|
|
expect(mockExec).toHaveBeenCalledWith(
|
|
expect.any(String),
|
|
[
|
|
'-c',
|
|
'protocol.version=2',
|
|
'fetch',
|
|
'--no-tags',
|
|
'--prune',
|
|
'--no-recurse-submodules',
|
|
'--filter=filterValue',
|
|
'--depth=1',
|
|
'origin',
|
|
'refspec1',
|
|
'refspec2',
|
|
'+refs/tags/*:refs/tags/*'
|
|
],
|
|
expect.any(Object)
|
|
)
|
|
})
|
|
|
|
it('should call execGit with the correct arguments when showProgress is true', async () => {
|
|
// exec.exec is already mockExec
|
|
|
|
const workingDirectory = 'test'
|
|
const lfs = false
|
|
const doSparseCheckout = false
|
|
git = await commandManager.createCommandManager(
|
|
workingDirectory,
|
|
lfs,
|
|
doSparseCheckout
|
|
)
|
|
const refSpec = ['refspec1', 'refspec2']
|
|
const options = {
|
|
filter: 'filterValue',
|
|
showProgress: true
|
|
}
|
|
|
|
await git.fetch(refSpec, options)
|
|
|
|
expect(mockExec).toHaveBeenCalledWith(
|
|
expect.any(String),
|
|
[
|
|
'-c',
|
|
'protocol.version=2',
|
|
'fetch',
|
|
'--no-tags',
|
|
'--prune',
|
|
'--no-recurse-submodules',
|
|
'--progress',
|
|
'--filter=filterValue',
|
|
'origin',
|
|
'refspec1',
|
|
'refspec2'
|
|
],
|
|
expect.any(Object)
|
|
)
|
|
})
|
|
|
|
it('should call execGit with the correct arguments when fetchDepth is 42 and showProgress is true', async () => {
|
|
// exec.exec is already mockExec
|
|
|
|
const workingDirectory = 'test'
|
|
const lfs = false
|
|
const doSparseCheckout = false
|
|
git = await commandManager.createCommandManager(
|
|
workingDirectory,
|
|
lfs,
|
|
doSparseCheckout
|
|
)
|
|
const refSpec = ['refspec1', 'refspec2']
|
|
const options = {
|
|
filter: 'filterValue',
|
|
fetchDepth: 42,
|
|
showProgress: true
|
|
}
|
|
|
|
await git.fetch(refSpec, options)
|
|
|
|
expect(mockExec).toHaveBeenCalledWith(
|
|
expect.any(String),
|
|
[
|
|
'-c',
|
|
'protocol.version=2',
|
|
'fetch',
|
|
'--no-tags',
|
|
'--prune',
|
|
'--no-recurse-submodules',
|
|
'--progress',
|
|
'--filter=filterValue',
|
|
'--depth=42',
|
|
'origin',
|
|
'refspec1',
|
|
'refspec2'
|
|
],
|
|
expect.any(Object)
|
|
)
|
|
})
|
|
|
|
it('should call execGit with the correct arguments when showProgress is true and refSpec includes tags', async () => {
|
|
// exec.exec is already mockExec
|
|
|
|
const workingDirectory = 'test'
|
|
const lfs = false
|
|
const doSparseCheckout = false
|
|
git = await commandManager.createCommandManager(
|
|
workingDirectory,
|
|
lfs,
|
|
doSparseCheckout
|
|
)
|
|
const refSpec = ['refspec1', 'refspec2', '+refs/tags/*:refs/tags/*']
|
|
const options = {
|
|
filter: 'filterValue',
|
|
showProgress: true
|
|
}
|
|
|
|
await git.fetch(refSpec, options)
|
|
|
|
expect(mockExec).toHaveBeenCalledWith(
|
|
expect.any(String),
|
|
[
|
|
'-c',
|
|
'protocol.version=2',
|
|
'fetch',
|
|
'--no-tags',
|
|
'--prune',
|
|
'--no-recurse-submodules',
|
|
'--progress',
|
|
'--filter=filterValue',
|
|
'origin',
|
|
'refspec1',
|
|
'refspec2',
|
|
'+refs/tags/*:refs/tags/*'
|
|
],
|
|
expect.any(Object)
|
|
)
|
|
})
|
|
})
|
|
|
|
describe('repository initialization object format', () => {
|
|
beforeEach(async () => {
|
|
mockFileExistsSync.mockReset()
|
|
mockDirectoryExistsSync.mockReset()
|
|
})
|
|
|
|
afterEach(() => {
|
|
jest.clearAllMocks()
|
|
})
|
|
|
|
it('initializes SHA-256 repositories with the matching object format', async () => {
|
|
mockExec.mockImplementation((path: any, args: any, options: any) => {
|
|
if (args.includes('version')) {
|
|
options.listeners.stdout(Buffer.from('git version 2.50.1'))
|
|
}
|
|
|
|
return 0
|
|
})
|
|
// exec.exec is already mockExec
|
|
|
|
git = await commandManager.createCommandManager('test', false, false)
|
|
|
|
await git.init('sha256')
|
|
|
|
expect(mockExec).toHaveBeenCalledWith(
|
|
expect.any(String),
|
|
['init', '--object-format=sha256', 'test'],
|
|
expect.any(Object)
|
|
)
|
|
})
|
|
|
|
it('initializes SHA-1 repositories with existing default arguments', async () => {
|
|
mockExec.mockImplementation((path: any, args: any, options: any) => {
|
|
if (args.includes('version')) {
|
|
options.listeners.stdout(Buffer.from('git version 2.50.1'))
|
|
}
|
|
|
|
return 0
|
|
})
|
|
// exec.exec is already mockExec
|
|
|
|
git = await commandManager.createCommandManager('test', false, false)
|
|
|
|
await git.init('sha1')
|
|
|
|
expect(mockExec).toHaveBeenCalledWith(
|
|
expect.any(String),
|
|
['init', 'test'],
|
|
expect.any(Object)
|
|
)
|
|
})
|
|
})
|
|
|
|
describe('git user-agent with orchestration ID', () => {
|
|
beforeEach(async () => {
|
|
mockFileExistsSync.mockReset()
|
|
mockDirectoryExistsSync.mockReset()
|
|
})
|
|
|
|
afterEach(() => {
|
|
jest.clearAllMocks()
|
|
// Clean up environment variable to prevent test pollution
|
|
delete process.env['ACTIONS_ORCHESTRATION_ID']
|
|
})
|
|
|
|
it('should include orchestration ID in user-agent when ACTIONS_ORCHESTRATION_ID is set', async () => {
|
|
const orchId = 'test-orch-id-12345'
|
|
process.env['ACTIONS_ORCHESTRATION_ID'] = orchId
|
|
|
|
let capturedEnv: any = null
|
|
mockExec.mockImplementation((path: any, args: any, options: any) => {
|
|
if (args.includes('version')) {
|
|
options.listeners.stdout(Buffer.from('2.18'))
|
|
}
|
|
// Capture env on any command
|
|
capturedEnv = options.env
|
|
return 0
|
|
})
|
|
// exec.exec is already mockExec
|
|
|
|
const workingDirectory = 'test'
|
|
const lfs = false
|
|
const doSparseCheckout = false
|
|
git = await commandManager.createCommandManager(
|
|
workingDirectory,
|
|
lfs,
|
|
doSparseCheckout
|
|
)
|
|
|
|
// Call a git command to trigger env capture after user-agent is set
|
|
await git.init()
|
|
|
|
// Verify the user agent includes the orchestration ID
|
|
expect(git).toBeDefined()
|
|
expect(capturedEnv).toBeDefined()
|
|
expect(capturedEnv['GIT_HTTP_USER_AGENT']).toBe(
|
|
`git/2.18 (github-actions-checkout) actions_orchestration_id/${orchId}`
|
|
)
|
|
})
|
|
|
|
it('should sanitize invalid characters in orchestration ID', async () => {
|
|
const orchId = 'test (with) special/chars'
|
|
process.env['ACTIONS_ORCHESTRATION_ID'] = orchId
|
|
|
|
let capturedEnv: any = null
|
|
mockExec.mockImplementation((path: any, args: any, options: any) => {
|
|
if (args.includes('version')) {
|
|
options.listeners.stdout(Buffer.from('2.18'))
|
|
}
|
|
// Capture env on any command
|
|
capturedEnv = options.env
|
|
return 0
|
|
})
|
|
// exec.exec is already mockExec
|
|
|
|
const workingDirectory = 'test'
|
|
const lfs = false
|
|
const doSparseCheckout = false
|
|
git = await commandManager.createCommandManager(
|
|
workingDirectory,
|
|
lfs,
|
|
doSparseCheckout
|
|
)
|
|
|
|
// Call a git command to trigger env capture after user-agent is set
|
|
await git.init()
|
|
|
|
// Verify the user agent has sanitized orchestration ID (spaces, parentheses, slash replaced)
|
|
expect(git).toBeDefined()
|
|
expect(capturedEnv).toBeDefined()
|
|
expect(capturedEnv['GIT_HTTP_USER_AGENT']).toBe(
|
|
'git/2.18 (github-actions-checkout) actions_orchestration_id/test__with__special_chars'
|
|
)
|
|
})
|
|
|
|
it('should not modify user-agent when ACTIONS_ORCHESTRATION_ID is not set', async () => {
|
|
delete process.env['ACTIONS_ORCHESTRATION_ID']
|
|
|
|
let capturedEnv: any = null
|
|
mockExec.mockImplementation((path: any, args: any, options: any) => {
|
|
if (args.includes('version')) {
|
|
options.listeners.stdout(Buffer.from('2.18'))
|
|
}
|
|
// Capture env on any command
|
|
capturedEnv = options.env
|
|
return 0
|
|
})
|
|
// exec.exec is already mockExec
|
|
|
|
const workingDirectory = 'test'
|
|
const lfs = false
|
|
const doSparseCheckout = false
|
|
git = await commandManager.createCommandManager(
|
|
workingDirectory,
|
|
lfs,
|
|
doSparseCheckout
|
|
)
|
|
|
|
// Call a git command to trigger env capture after user-agent is set
|
|
await git.init()
|
|
|
|
// Verify the user agent does NOT contain orchestration ID
|
|
expect(git).toBeDefined()
|
|
expect(capturedEnv).toBeDefined()
|
|
expect(capturedEnv['GIT_HTTP_USER_AGENT']).toBe(
|
|
'git/2.18 (github-actions-checkout)'
|
|
)
|
|
})
|
|
})
|
|
|
|
describe('Test quiet option', () => {
|
|
beforeEach(async () => {
|
|
mockFileExistsSync.mockReset()
|
|
mockDirectoryExistsSync.mockReset()
|
|
mockExec.mockImplementation((path: any, args: any, options: any) => {
|
|
if (args.includes('version')) {
|
|
options.listeners.stdout(Buffer.from('2.18'))
|
|
}
|
|
|
|
return 0
|
|
})
|
|
})
|
|
|
|
afterEach(() => {
|
|
jest.clearAllMocks()
|
|
})
|
|
|
|
async function createManager(quiet?: boolean): Promise<IGitCommandManager> {
|
|
const workingDirectory = 'test'
|
|
const lfs = false
|
|
const doSparseCheckout = false
|
|
return await commandManager.createCommandManager(
|
|
workingDirectory,
|
|
lfs,
|
|
doSparseCheckout,
|
|
quiet
|
|
)
|
|
}
|
|
|
|
it('should pass --quiet to fetch when quiet is true', async () => {
|
|
git = await createManager(true)
|
|
|
|
await git.fetch(['refspec1'], {fetchDepth: 0})
|
|
|
|
expect(mockExec).toHaveBeenCalledWith(
|
|
expect.any(String),
|
|
[
|
|
'-c',
|
|
'protocol.version=2',
|
|
'fetch',
|
|
'--no-tags',
|
|
'--prune',
|
|
'--no-recurse-submodules',
|
|
'--quiet',
|
|
'origin',
|
|
'refspec1'
|
|
],
|
|
expect.any(Object)
|
|
)
|
|
})
|
|
|
|
it('should pass both --quiet and --progress to fetch when both are requested', async () => {
|
|
// The two flags drive different output and compose: --progress forces the
|
|
// transfer meter, --quiet drops the per-ref summary.
|
|
git = await createManager(true)
|
|
|
|
await git.fetch(['refspec1'], {fetchDepth: 0, showProgress: true})
|
|
|
|
const args = mockExec.mock.calls.at(-1)?.[1] as string[]
|
|
expect(args).toContain('--quiet')
|
|
expect(args).toContain('--progress')
|
|
})
|
|
|
|
it('should not pass --quiet to fetch when quiet is false', async () => {
|
|
git = await createManager(false)
|
|
|
|
await git.fetch(['refspec1'], {fetchDepth: 0})
|
|
|
|
expect(mockExec).toHaveBeenCalledWith(
|
|
expect.any(String),
|
|
[
|
|
'-c',
|
|
'protocol.version=2',
|
|
'fetch',
|
|
'--no-tags',
|
|
'--prune',
|
|
'--no-recurse-submodules',
|
|
'origin',
|
|
'refspec1'
|
|
],
|
|
expect.any(Object)
|
|
)
|
|
})
|
|
|
|
it('should default to not quiet when the option is omitted', async () => {
|
|
git = await createManager()
|
|
|
|
await git.fetch(['refspec1'], {fetchDepth: 0, showProgress: true})
|
|
|
|
const args = mockExec.mock.calls.at(-1)?.[1] as string[]
|
|
expect(args).toContain('--progress')
|
|
expect(args).not.toContain('--quiet')
|
|
})
|
|
|
|
it('should checkout with --quiet alongside --progress when quiet is true', async () => {
|
|
git = await createManager(true)
|
|
|
|
await git.checkout('refs/heads/main', '')
|
|
|
|
expect(mockExec).toHaveBeenCalledWith(
|
|
expect.any(String),
|
|
['checkout', '--quiet', '--progress', '--force', 'refs/heads/main'],
|
|
expect.any(Object)
|
|
)
|
|
})
|
|
|
|
it('should checkout a start point with --quiet when quiet is true', async () => {
|
|
git = await createManager(true)
|
|
|
|
await git.checkout('refs/heads/main', 'refs/remotes/origin/main')
|
|
|
|
expect(mockExec).toHaveBeenCalledWith(
|
|
expect.any(String),
|
|
[
|
|
'checkout',
|
|
'--quiet',
|
|
'--progress',
|
|
'--force',
|
|
'-B',
|
|
'refs/heads/main',
|
|
'refs/remotes/origin/main'
|
|
],
|
|
expect.any(Object)
|
|
)
|
|
})
|
|
|
|
it('should checkout with --progress when quiet is false', async () => {
|
|
git = await createManager(false)
|
|
|
|
await git.checkout('refs/heads/main', '')
|
|
|
|
expect(mockExec).toHaveBeenCalledWith(
|
|
expect.any(String),
|
|
['checkout', '--progress', '--force', 'refs/heads/main'],
|
|
expect.any(Object)
|
|
)
|
|
})
|
|
|
|
it('should pass --quiet to checkout --detach when quiet is true', async () => {
|
|
git = await createManager(true)
|
|
|
|
await git.checkoutDetach()
|
|
|
|
expect(mockExec).toHaveBeenCalledWith(
|
|
expect.any(String),
|
|
['checkout', '--detach', '--quiet'],
|
|
expect.any(Object)
|
|
)
|
|
})
|
|
|
|
it('should not pass --quiet to checkout --detach when quiet is false', async () => {
|
|
git = await createManager(false)
|
|
|
|
await git.checkoutDetach()
|
|
|
|
expect(mockExec).toHaveBeenCalledWith(
|
|
expect.any(String),
|
|
['checkout', '--detach'],
|
|
expect.any(Object)
|
|
)
|
|
})
|
|
|
|
it('should pass --quiet to submodule update when quiet is true', async () => {
|
|
git = await createManager(true)
|
|
|
|
await git.submoduleUpdate(1, true)
|
|
|
|
expect(mockExec).toHaveBeenCalledWith(
|
|
expect.any(String),
|
|
[
|
|
'-c',
|
|
'protocol.version=2',
|
|
'submodule',
|
|
'update',
|
|
'--init',
|
|
'--force',
|
|
'--quiet',
|
|
'--depth=1',
|
|
'--recursive'
|
|
],
|
|
expect.any(Object)
|
|
)
|
|
})
|
|
|
|
it('should not pass --quiet to submodule update when quiet is false', async () => {
|
|
git = await createManager(false)
|
|
|
|
await git.submoduleUpdate(1, true)
|
|
|
|
expect(mockExec).toHaveBeenCalledWith(
|
|
expect.any(String),
|
|
[
|
|
'-c',
|
|
'protocol.version=2',
|
|
'submodule',
|
|
'update',
|
|
'--init',
|
|
'--force',
|
|
'--depth=1',
|
|
'--recursive'
|
|
],
|
|
expect.any(Object)
|
|
)
|
|
})
|
|
})
|