mirror of
https://code.forgejo.org/actions/checkout.git
synced 2024-12-25 12:05:51 +00:00
e6d535c99c
* Adding the ability to specify the GitHub Server URL and allowing for it to differ from the Actions workflow host * Adding tests for injecting the GitHub URL * Addressing code review comments for PR #922
843 lines
27 KiB
TypeScript
843 lines
27 KiB
TypeScript
import * as core from '@actions/core'
|
|
import * as fs from 'fs'
|
|
import * as gitAuthHelper from '../lib/git-auth-helper'
|
|
import * as io from '@actions/io'
|
|
import * as os from 'os'
|
|
import * as path from 'path'
|
|
import * as stateHelper from '../lib/state-helper'
|
|
import {IGitCommandManager} from '../lib/git-command-manager'
|
|
import {IGitSourceSettings} from '../lib/git-source-settings'
|
|
|
|
const isWindows = process.platform === 'win32'
|
|
const testWorkspace = path.join(__dirname, '_temp', 'git-auth-helper')
|
|
const originalRunnerTemp = process.env['RUNNER_TEMP']
|
|
const originalHome = process.env['HOME']
|
|
let workspace: string
|
|
let localGitConfigPath: string
|
|
let globalGitConfigPath: string
|
|
let runnerTemp: string
|
|
let tempHomedir: string
|
|
let git: IGitCommandManager & {env: {[key: string]: string}}
|
|
let settings: IGitSourceSettings
|
|
let sshPath: string
|
|
let githubServerUrl: string
|
|
|
|
describe('git-auth-helper tests', () => {
|
|
beforeAll(async () => {
|
|
// SSH
|
|
sshPath = await io.which('ssh')
|
|
|
|
// Clear test workspace
|
|
await io.rmRF(testWorkspace)
|
|
})
|
|
|
|
beforeEach(() => {
|
|
// Mock setSecret
|
|
jest.spyOn(core, 'setSecret').mockImplementation((secret: string) => {})
|
|
|
|
// Mock error/warning/info/debug
|
|
jest.spyOn(core, 'error').mockImplementation(jest.fn())
|
|
jest.spyOn(core, 'warning').mockImplementation(jest.fn())
|
|
jest.spyOn(core, 'info').mockImplementation(jest.fn())
|
|
jest.spyOn(core, 'debug').mockImplementation(jest.fn())
|
|
|
|
// Mock state helper
|
|
jest.spyOn(stateHelper, 'setSshKeyPath').mockImplementation(jest.fn())
|
|
jest
|
|
.spyOn(stateHelper, 'setSshKnownHostsPath')
|
|
.mockImplementation(jest.fn())
|
|
})
|
|
|
|
afterEach(() => {
|
|
// Unregister mocks
|
|
jest.restoreAllMocks()
|
|
|
|
// Restore HOME
|
|
if (originalHome) {
|
|
process.env['HOME'] = originalHome
|
|
} else {
|
|
delete process.env['HOME']
|
|
}
|
|
})
|
|
|
|
afterAll(() => {
|
|
// Restore RUNNER_TEMP
|
|
delete process.env['RUNNER_TEMP']
|
|
if (originalRunnerTemp) {
|
|
process.env['RUNNER_TEMP'] = originalRunnerTemp
|
|
}
|
|
})
|
|
|
|
async function testAuthHeader(
|
|
testName: string,
|
|
serverUrl: string | undefined = undefined
|
|
) {
|
|
// Arrange
|
|
let expectedServerUrl = 'https://github.com'
|
|
if (serverUrl) {
|
|
githubServerUrl = serverUrl
|
|
expectedServerUrl = githubServerUrl
|
|
}
|
|
|
|
await setup(testName)
|
|
expect(settings.authToken).toBeTruthy() // sanity check
|
|
const authHelper = gitAuthHelper.createAuthHelper(git, settings)
|
|
|
|
// Act
|
|
await authHelper.configureAuth()
|
|
|
|
// Assert config
|
|
const configContent = (
|
|
await fs.promises.readFile(localGitConfigPath)
|
|
).toString()
|
|
const basicCredential = Buffer.from(
|
|
`x-access-token:${settings.authToken}`,
|
|
'utf8'
|
|
).toString('base64')
|
|
expect(
|
|
configContent.indexOf(
|
|
`http.${expectedServerUrl}/.extraheader AUTHORIZATION: basic ${basicCredential}`
|
|
)
|
|
).toBeGreaterThanOrEqual(0)
|
|
}
|
|
|
|
const configureAuth_configuresAuthHeader =
|
|
'configureAuth configures auth header'
|
|
it(configureAuth_configuresAuthHeader, async () => {
|
|
await testAuthHeader(configureAuth_configuresAuthHeader)
|
|
})
|
|
|
|
const configureAuth_AcceptsGitHubServerUrl =
|
|
'inject https://my-ghes-server.com as github server url'
|
|
it(configureAuth_AcceptsGitHubServerUrl, async () => {
|
|
await testAuthHeader(
|
|
configureAuth_AcceptsGitHubServerUrl,
|
|
'https://my-ghes-server.com'
|
|
)
|
|
})
|
|
|
|
const configureAuth_AcceptsGitHubServerUrlSetToGHEC =
|
|
'inject https://github.com as github server url'
|
|
it(configureAuth_AcceptsGitHubServerUrlSetToGHEC, async () => {
|
|
await testAuthHeader(
|
|
configureAuth_AcceptsGitHubServerUrl,
|
|
'https://github.com'
|
|
)
|
|
})
|
|
|
|
const configureAuth_configuresAuthHeaderEvenWhenPersistCredentialsFalse =
|
|
'configureAuth configures auth header even when persist credentials false'
|
|
it(
|
|
configureAuth_configuresAuthHeaderEvenWhenPersistCredentialsFalse,
|
|
async () => {
|
|
// Arrange
|
|
await setup(
|
|
configureAuth_configuresAuthHeaderEvenWhenPersistCredentialsFalse
|
|
)
|
|
expect(settings.authToken).toBeTruthy() // sanity check
|
|
settings.persistCredentials = false
|
|
const authHelper = gitAuthHelper.createAuthHelper(git, settings)
|
|
|
|
// Act
|
|
await authHelper.configureAuth()
|
|
|
|
// Assert config
|
|
const configContent = (
|
|
await fs.promises.readFile(localGitConfigPath)
|
|
).toString()
|
|
expect(
|
|
configContent.indexOf(
|
|
`http.https://github.com/.extraheader AUTHORIZATION`
|
|
)
|
|
).toBeGreaterThanOrEqual(0)
|
|
}
|
|
)
|
|
|
|
const configureAuth_copiesUserKnownHosts =
|
|
'configureAuth copies user known hosts'
|
|
it(configureAuth_copiesUserKnownHosts, async () => {
|
|
if (!sshPath) {
|
|
process.stdout.write(
|
|
`Skipped test "${configureAuth_copiesUserKnownHosts}". Executable 'ssh' not found in the PATH.\n`
|
|
)
|
|
return
|
|
}
|
|
|
|
// Arange
|
|
await setup(configureAuth_copiesUserKnownHosts)
|
|
expect(settings.sshKey).toBeTruthy() // sanity check
|
|
|
|
// Mock fs.promises.readFile
|
|
const realReadFile = fs.promises.readFile
|
|
jest.spyOn(fs.promises, 'readFile').mockImplementation(
|
|
async (file: any, options: any): Promise<Buffer> => {
|
|
const userKnownHostsPath = path.join(
|
|
os.homedir(),
|
|
'.ssh',
|
|
'known_hosts'
|
|
)
|
|
if (file === userKnownHostsPath) {
|
|
return Buffer.from('some-domain.com ssh-rsa ABCDEF')
|
|
}
|
|
|
|
return await realReadFile(file, options)
|
|
}
|
|
)
|
|
|
|
// Act
|
|
const authHelper = gitAuthHelper.createAuthHelper(git, settings)
|
|
await authHelper.configureAuth()
|
|
|
|
// Assert known hosts
|
|
const actualSshKnownHostsPath = await getActualSshKnownHostsPath()
|
|
const actualSshKnownHostsContent = (
|
|
await fs.promises.readFile(actualSshKnownHostsPath)
|
|
).toString()
|
|
expect(actualSshKnownHostsContent).toMatch(
|
|
/some-domain\.com ssh-rsa ABCDEF/
|
|
)
|
|
expect(actualSshKnownHostsContent).toMatch(/github\.com ssh-rsa AAAAB3N/)
|
|
})
|
|
|
|
const configureAuth_registersBasicCredentialAsSecret =
|
|
'configureAuth registers basic credential as secret'
|
|
it(configureAuth_registersBasicCredentialAsSecret, async () => {
|
|
// Arrange
|
|
await setup(configureAuth_registersBasicCredentialAsSecret)
|
|
expect(settings.authToken).toBeTruthy() // sanity check
|
|
const authHelper = gitAuthHelper.createAuthHelper(git, settings)
|
|
|
|
// Act
|
|
await authHelper.configureAuth()
|
|
|
|
// Assert secret
|
|
const setSecretSpy = core.setSecret as jest.Mock<any, any>
|
|
expect(setSecretSpy).toHaveBeenCalledTimes(1)
|
|
const expectedSecret = Buffer.from(
|
|
`x-access-token:${settings.authToken}`,
|
|
'utf8'
|
|
).toString('base64')
|
|
expect(setSecretSpy).toHaveBeenCalledWith(expectedSecret)
|
|
})
|
|
|
|
const setsSshCommandEnvVarWhenPersistCredentialsFalse =
|
|
'sets SSH command env var when persist-credentials false'
|
|
it(setsSshCommandEnvVarWhenPersistCredentialsFalse, async () => {
|
|
if (!sshPath) {
|
|
process.stdout.write(
|
|
`Skipped test "${setsSshCommandEnvVarWhenPersistCredentialsFalse}". Executable 'ssh' not found in the PATH.\n`
|
|
)
|
|
return
|
|
}
|
|
|
|
// Arrange
|
|
await setup(setsSshCommandEnvVarWhenPersistCredentialsFalse)
|
|
settings.persistCredentials = false
|
|
const authHelper = gitAuthHelper.createAuthHelper(git, settings)
|
|
|
|
// Act
|
|
await authHelper.configureAuth()
|
|
|
|
// Assert git env var
|
|
const actualKeyPath = await getActualSshKeyPath()
|
|
const actualKnownHostsPath = await getActualSshKnownHostsPath()
|
|
const expectedSshCommand = `"${sshPath}" -i "$RUNNER_TEMP/${path.basename(
|
|
actualKeyPath
|
|
)}" -o StrictHostKeyChecking=yes -o CheckHostIP=no -o "UserKnownHostsFile=$RUNNER_TEMP/${path.basename(
|
|
actualKnownHostsPath
|
|
)}"`
|
|
expect(git.setEnvironmentVariable).toHaveBeenCalledWith(
|
|
'GIT_SSH_COMMAND',
|
|
expectedSshCommand
|
|
)
|
|
|
|
// Asserty git config
|
|
const gitConfigLines = (await fs.promises.readFile(localGitConfigPath))
|
|
.toString()
|
|
.split('\n')
|
|
.filter(x => x)
|
|
expect(gitConfigLines).toHaveLength(1)
|
|
expect(gitConfigLines[0]).toMatch(/^http\./)
|
|
})
|
|
|
|
const configureAuth_setsSshCommandWhenPersistCredentialsTrue =
|
|
'sets SSH command when persist-credentials true'
|
|
it(configureAuth_setsSshCommandWhenPersistCredentialsTrue, async () => {
|
|
if (!sshPath) {
|
|
process.stdout.write(
|
|
`Skipped test "${configureAuth_setsSshCommandWhenPersistCredentialsTrue}". Executable 'ssh' not found in the PATH.\n`
|
|
)
|
|
return
|
|
}
|
|
|
|
// Arrange
|
|
await setup(configureAuth_setsSshCommandWhenPersistCredentialsTrue)
|
|
const authHelper = gitAuthHelper.createAuthHelper(git, settings)
|
|
|
|
// Act
|
|
await authHelper.configureAuth()
|
|
|
|
// Assert git env var
|
|
const actualKeyPath = await getActualSshKeyPath()
|
|
const actualKnownHostsPath = await getActualSshKnownHostsPath()
|
|
const expectedSshCommand = `"${sshPath}" -i "$RUNNER_TEMP/${path.basename(
|
|
actualKeyPath
|
|
)}" -o StrictHostKeyChecking=yes -o CheckHostIP=no -o "UserKnownHostsFile=$RUNNER_TEMP/${path.basename(
|
|
actualKnownHostsPath
|
|
)}"`
|
|
expect(git.setEnvironmentVariable).toHaveBeenCalledWith(
|
|
'GIT_SSH_COMMAND',
|
|
expectedSshCommand
|
|
)
|
|
|
|
// Asserty git config
|
|
expect(git.config).toHaveBeenCalledWith(
|
|
'core.sshCommand',
|
|
expectedSshCommand
|
|
)
|
|
})
|
|
|
|
const configureAuth_writesExplicitKnownHosts = 'writes explicit known hosts'
|
|
it(configureAuth_writesExplicitKnownHosts, async () => {
|
|
if (!sshPath) {
|
|
process.stdout.write(
|
|
`Skipped test "${configureAuth_writesExplicitKnownHosts}". Executable 'ssh' not found in the PATH.\n`
|
|
)
|
|
return
|
|
}
|
|
|
|
// Arrange
|
|
await setup(configureAuth_writesExplicitKnownHosts)
|
|
expect(settings.sshKey).toBeTruthy() // sanity check
|
|
settings.sshKnownHosts = 'my-custom-host.com ssh-rsa ABC123'
|
|
const authHelper = gitAuthHelper.createAuthHelper(git, settings)
|
|
|
|
// Act
|
|
await authHelper.configureAuth()
|
|
|
|
// Assert known hosts
|
|
const actualSshKnownHostsPath = await getActualSshKnownHostsPath()
|
|
const actualSshKnownHostsContent = (
|
|
await fs.promises.readFile(actualSshKnownHostsPath)
|
|
).toString()
|
|
expect(actualSshKnownHostsContent).toMatch(
|
|
/my-custom-host\.com ssh-rsa ABC123/
|
|
)
|
|
expect(actualSshKnownHostsContent).toMatch(/github\.com ssh-rsa AAAAB3N/)
|
|
})
|
|
|
|
const configureAuth_writesSshKeyAndImplicitKnownHosts =
|
|
'writes SSH key and implicit known hosts'
|
|
it(configureAuth_writesSshKeyAndImplicitKnownHosts, async () => {
|
|
if (!sshPath) {
|
|
process.stdout.write(
|
|
`Skipped test "${configureAuth_writesSshKeyAndImplicitKnownHosts}". Executable 'ssh' not found in the PATH.\n`
|
|
)
|
|
return
|
|
}
|
|
|
|
// Arrange
|
|
await setup(configureAuth_writesSshKeyAndImplicitKnownHosts)
|
|
expect(settings.sshKey).toBeTruthy() // sanity check
|
|
const authHelper = gitAuthHelper.createAuthHelper(git, settings)
|
|
|
|
// Act
|
|
await authHelper.configureAuth()
|
|
|
|
// Assert SSH key
|
|
const actualSshKeyPath = await getActualSshKeyPath()
|
|
expect(actualSshKeyPath).toBeTruthy()
|
|
const actualSshKeyContent = (
|
|
await fs.promises.readFile(actualSshKeyPath)
|
|
).toString()
|
|
expect(actualSshKeyContent).toBe(settings.sshKey + '\n')
|
|
if (!isWindows) {
|
|
// Assert read/write for user, not group or others.
|
|
// Otherwise SSH client will error.
|
|
expect((await fs.promises.stat(actualSshKeyPath)).mode & 0o777).toBe(
|
|
0o600
|
|
)
|
|
}
|
|
|
|
// Assert known hosts
|
|
const actualSshKnownHostsPath = await getActualSshKnownHostsPath()
|
|
const actualSshKnownHostsContent = (
|
|
await fs.promises.readFile(actualSshKnownHostsPath)
|
|
).toString()
|
|
expect(actualSshKnownHostsContent).toMatch(/github\.com ssh-rsa AAAAB3N/)
|
|
})
|
|
|
|
const configureGlobalAuth_configuresUrlInsteadOfWhenSshKeyNotSet =
|
|
'configureGlobalAuth configures URL insteadOf when SSH key not set'
|
|
it(configureGlobalAuth_configuresUrlInsteadOfWhenSshKeyNotSet, async () => {
|
|
// Arrange
|
|
await setup(configureGlobalAuth_configuresUrlInsteadOfWhenSshKeyNotSet)
|
|
settings.sshKey = ''
|
|
const authHelper = gitAuthHelper.createAuthHelper(git, settings)
|
|
|
|
// Act
|
|
await authHelper.configureAuth()
|
|
await authHelper.configureGlobalAuth()
|
|
|
|
// Assert temporary global config
|
|
expect(git.env['HOME']).toBeTruthy()
|
|
const configContent = (
|
|
await fs.promises.readFile(path.join(git.env['HOME'], '.gitconfig'))
|
|
).toString()
|
|
expect(
|
|
configContent.indexOf(`url.https://github.com/.insteadOf git@github.com`)
|
|
).toBeGreaterThanOrEqual(0)
|
|
})
|
|
|
|
const configureGlobalAuth_copiesGlobalGitConfig =
|
|
'configureGlobalAuth copies global git config'
|
|
it(configureGlobalAuth_copiesGlobalGitConfig, async () => {
|
|
// Arrange
|
|
await setup(configureGlobalAuth_copiesGlobalGitConfig)
|
|
await fs.promises.writeFile(globalGitConfigPath, 'value-from-global-config')
|
|
const authHelper = gitAuthHelper.createAuthHelper(git, settings)
|
|
|
|
// Act
|
|
await authHelper.configureAuth()
|
|
await authHelper.configureGlobalAuth()
|
|
|
|
// Assert original global config not altered
|
|
let configContent = (
|
|
await fs.promises.readFile(globalGitConfigPath)
|
|
).toString()
|
|
expect(configContent).toBe('value-from-global-config')
|
|
|
|
// Assert temporary global config
|
|
expect(git.env['HOME']).toBeTruthy()
|
|
const basicCredential = Buffer.from(
|
|
`x-access-token:${settings.authToken}`,
|
|
'utf8'
|
|
).toString('base64')
|
|
configContent = (
|
|
await fs.promises.readFile(path.join(git.env['HOME'], '.gitconfig'))
|
|
).toString()
|
|
expect(
|
|
configContent.indexOf('value-from-global-config')
|
|
).toBeGreaterThanOrEqual(0)
|
|
expect(
|
|
configContent.indexOf(
|
|
`http.https://github.com/.extraheader AUTHORIZATION: basic ${basicCredential}`
|
|
)
|
|
).toBeGreaterThanOrEqual(0)
|
|
})
|
|
|
|
const configureGlobalAuth_createsNewGlobalGitConfigWhenGlobalDoesNotExist =
|
|
'configureGlobalAuth creates new git config when global does not exist'
|
|
it(
|
|
configureGlobalAuth_createsNewGlobalGitConfigWhenGlobalDoesNotExist,
|
|
async () => {
|
|
// Arrange
|
|
await setup(
|
|
configureGlobalAuth_createsNewGlobalGitConfigWhenGlobalDoesNotExist
|
|
)
|
|
await io.rmRF(globalGitConfigPath)
|
|
const authHelper = gitAuthHelper.createAuthHelper(git, settings)
|
|
|
|
// Act
|
|
await authHelper.configureAuth()
|
|
await authHelper.configureGlobalAuth()
|
|
|
|
// Assert original global config not recreated
|
|
try {
|
|
await fs.promises.stat(globalGitConfigPath)
|
|
throw new Error(
|
|
`Did not expect file to exist: '${globalGitConfigPath}'`
|
|
)
|
|
} catch (err) {
|
|
if ((err as any)?.code !== 'ENOENT') {
|
|
throw err
|
|
}
|
|
}
|
|
|
|
// Assert temporary global config
|
|
expect(git.env['HOME']).toBeTruthy()
|
|
const basicCredential = Buffer.from(
|
|
`x-access-token:${settings.authToken}`,
|
|
'utf8'
|
|
).toString('base64')
|
|
const configContent = (
|
|
await fs.promises.readFile(path.join(git.env['HOME'], '.gitconfig'))
|
|
).toString()
|
|
expect(
|
|
configContent.indexOf(
|
|
`http.https://github.com/.extraheader AUTHORIZATION: basic ${basicCredential}`
|
|
)
|
|
).toBeGreaterThanOrEqual(0)
|
|
}
|
|
)
|
|
|
|
const configureSubmoduleAuth_configuresSubmodulesWhenPersistCredentialsFalseAndSshKeyNotSet =
|
|
'configureSubmoduleAuth configures submodules when persist credentials false and SSH key not set'
|
|
it(
|
|
configureSubmoduleAuth_configuresSubmodulesWhenPersistCredentialsFalseAndSshKeyNotSet,
|
|
async () => {
|
|
// Arrange
|
|
await setup(
|
|
configureSubmoduleAuth_configuresSubmodulesWhenPersistCredentialsFalseAndSshKeyNotSet
|
|
)
|
|
settings.persistCredentials = false
|
|
settings.sshKey = ''
|
|
const authHelper = gitAuthHelper.createAuthHelper(git, settings)
|
|
await authHelper.configureAuth()
|
|
const mockSubmoduleForeach = git.submoduleForeach as jest.Mock<any, any>
|
|
mockSubmoduleForeach.mockClear() // reset calls
|
|
|
|
// Act
|
|
await authHelper.configureSubmoduleAuth()
|
|
|
|
// Assert
|
|
expect(mockSubmoduleForeach).toBeCalledTimes(1)
|
|
expect(mockSubmoduleForeach.mock.calls[0][0] as string).toMatch(
|
|
/unset-all.*insteadOf/
|
|
)
|
|
}
|
|
)
|
|
|
|
const configureSubmoduleAuth_configuresSubmodulesWhenPersistCredentialsFalseAndSshKeySet =
|
|
'configureSubmoduleAuth configures submodules when persist credentials false and SSH key set'
|
|
it(
|
|
configureSubmoduleAuth_configuresSubmodulesWhenPersistCredentialsFalseAndSshKeySet,
|
|
async () => {
|
|
if (!sshPath) {
|
|
process.stdout.write(
|
|
`Skipped test "${configureSubmoduleAuth_configuresSubmodulesWhenPersistCredentialsFalseAndSshKeySet}". Executable 'ssh' not found in the PATH.\n`
|
|
)
|
|
return
|
|
}
|
|
|
|
// Arrange
|
|
await setup(
|
|
configureSubmoduleAuth_configuresSubmodulesWhenPersistCredentialsFalseAndSshKeySet
|
|
)
|
|
settings.persistCredentials = false
|
|
const authHelper = gitAuthHelper.createAuthHelper(git, settings)
|
|
await authHelper.configureAuth()
|
|
const mockSubmoduleForeach = git.submoduleForeach as jest.Mock<any, any>
|
|
mockSubmoduleForeach.mockClear() // reset calls
|
|
|
|
// Act
|
|
await authHelper.configureSubmoduleAuth()
|
|
|
|
// Assert
|
|
expect(mockSubmoduleForeach).toHaveBeenCalledTimes(1)
|
|
expect(mockSubmoduleForeach.mock.calls[0][0]).toMatch(
|
|
/unset-all.*insteadOf/
|
|
)
|
|
}
|
|
)
|
|
|
|
const configureSubmoduleAuth_configuresSubmodulesWhenPersistCredentialsTrueAndSshKeyNotSet =
|
|
'configureSubmoduleAuth configures submodules when persist credentials true and SSH key not set'
|
|
it(
|
|
configureSubmoduleAuth_configuresSubmodulesWhenPersistCredentialsTrueAndSshKeyNotSet,
|
|
async () => {
|
|
// Arrange
|
|
await setup(
|
|
configureSubmoduleAuth_configuresSubmodulesWhenPersistCredentialsTrueAndSshKeyNotSet
|
|
)
|
|
settings.sshKey = ''
|
|
const authHelper = gitAuthHelper.createAuthHelper(git, settings)
|
|
await authHelper.configureAuth()
|
|
const mockSubmoduleForeach = git.submoduleForeach as jest.Mock<any, any>
|
|
mockSubmoduleForeach.mockClear() // reset calls
|
|
|
|
// Act
|
|
await authHelper.configureSubmoduleAuth()
|
|
|
|
// Assert
|
|
expect(mockSubmoduleForeach).toHaveBeenCalledTimes(4)
|
|
expect(mockSubmoduleForeach.mock.calls[0][0]).toMatch(
|
|
/unset-all.*insteadOf/
|
|
)
|
|
expect(mockSubmoduleForeach.mock.calls[1][0]).toMatch(/http.*extraheader/)
|
|
expect(mockSubmoduleForeach.mock.calls[2][0]).toMatch(
|
|
/url.*insteadOf.*git@github.com:/
|
|
)
|
|
expect(mockSubmoduleForeach.mock.calls[3][0]).toMatch(
|
|
/url.*insteadOf.*org-123456@github.com:/
|
|
)
|
|
}
|
|
)
|
|
|
|
const configureSubmoduleAuth_configuresSubmodulesWhenPersistCredentialsTrueAndSshKeySet =
|
|
'configureSubmoduleAuth configures submodules when persist credentials true and SSH key set'
|
|
it(
|
|
configureSubmoduleAuth_configuresSubmodulesWhenPersistCredentialsTrueAndSshKeySet,
|
|
async () => {
|
|
if (!sshPath) {
|
|
process.stdout.write(
|
|
`Skipped test "${configureSubmoduleAuth_configuresSubmodulesWhenPersistCredentialsTrueAndSshKeySet}". Executable 'ssh' not found in the PATH.\n`
|
|
)
|
|
return
|
|
}
|
|
|
|
// Arrange
|
|
await setup(
|
|
configureSubmoduleAuth_configuresSubmodulesWhenPersistCredentialsTrueAndSshKeySet
|
|
)
|
|
const authHelper = gitAuthHelper.createAuthHelper(git, settings)
|
|
await authHelper.configureAuth()
|
|
const mockSubmoduleForeach = git.submoduleForeach as jest.Mock<any, any>
|
|
mockSubmoduleForeach.mockClear() // reset calls
|
|
|
|
// Act
|
|
await authHelper.configureSubmoduleAuth()
|
|
|
|
// Assert
|
|
expect(mockSubmoduleForeach).toHaveBeenCalledTimes(3)
|
|
expect(mockSubmoduleForeach.mock.calls[0][0]).toMatch(
|
|
/unset-all.*insteadOf/
|
|
)
|
|
expect(mockSubmoduleForeach.mock.calls[1][0]).toMatch(/http.*extraheader/)
|
|
expect(mockSubmoduleForeach.mock.calls[2][0]).toMatch(/core\.sshCommand/)
|
|
}
|
|
)
|
|
|
|
const removeAuth_removesSshCommand = 'removeAuth removes SSH command'
|
|
it(removeAuth_removesSshCommand, async () => {
|
|
if (!sshPath) {
|
|
process.stdout.write(
|
|
`Skipped test "${removeAuth_removesSshCommand}". Executable 'ssh' not found in the PATH.\n`
|
|
)
|
|
return
|
|
}
|
|
|
|
// Arrange
|
|
await setup(removeAuth_removesSshCommand)
|
|
const authHelper = gitAuthHelper.createAuthHelper(git, settings)
|
|
await authHelper.configureAuth()
|
|
let gitConfigContent = (
|
|
await fs.promises.readFile(localGitConfigPath)
|
|
).toString()
|
|
expect(gitConfigContent.indexOf('core.sshCommand')).toBeGreaterThanOrEqual(
|
|
0
|
|
) // sanity check
|
|
const actualKeyPath = await getActualSshKeyPath()
|
|
expect(actualKeyPath).toBeTruthy()
|
|
await fs.promises.stat(actualKeyPath)
|
|
const actualKnownHostsPath = await getActualSshKnownHostsPath()
|
|
expect(actualKnownHostsPath).toBeTruthy()
|
|
await fs.promises.stat(actualKnownHostsPath)
|
|
|
|
// Act
|
|
await authHelper.removeAuth()
|
|
|
|
// Assert git config
|
|
gitConfigContent = (
|
|
await fs.promises.readFile(localGitConfigPath)
|
|
).toString()
|
|
expect(gitConfigContent.indexOf('core.sshCommand')).toBeLessThan(0)
|
|
|
|
// Assert SSH key file
|
|
try {
|
|
await fs.promises.stat(actualKeyPath)
|
|
throw new Error('SSH key should have been deleted')
|
|
} catch (err) {
|
|
if ((err as any)?.code !== 'ENOENT') {
|
|
throw err
|
|
}
|
|
}
|
|
|
|
// Assert known hosts file
|
|
try {
|
|
await fs.promises.stat(actualKnownHostsPath)
|
|
throw new Error('SSH known hosts should have been deleted')
|
|
} catch (err) {
|
|
if ((err as any)?.code !== 'ENOENT') {
|
|
throw err
|
|
}
|
|
}
|
|
})
|
|
|
|
const removeAuth_removesToken = 'removeAuth removes token'
|
|
it(removeAuth_removesToken, async () => {
|
|
// Arrange
|
|
await setup(removeAuth_removesToken)
|
|
const authHelper = gitAuthHelper.createAuthHelper(git, settings)
|
|
await authHelper.configureAuth()
|
|
let gitConfigContent = (
|
|
await fs.promises.readFile(localGitConfigPath)
|
|
).toString()
|
|
expect(gitConfigContent.indexOf('http.')).toBeGreaterThanOrEqual(0) // sanity check
|
|
|
|
// Act
|
|
await authHelper.removeAuth()
|
|
|
|
// Assert git config
|
|
gitConfigContent = (
|
|
await fs.promises.readFile(localGitConfigPath)
|
|
).toString()
|
|
expect(gitConfigContent.indexOf('http.')).toBeLessThan(0)
|
|
})
|
|
|
|
const removeGlobalConfig_removesOverride =
|
|
'removeGlobalConfig removes override'
|
|
it(removeGlobalConfig_removesOverride, async () => {
|
|
// Arrange
|
|
await setup(removeGlobalConfig_removesOverride)
|
|
const authHelper = gitAuthHelper.createAuthHelper(git, settings)
|
|
await authHelper.configureAuth()
|
|
await authHelper.configureGlobalAuth()
|
|
const homeOverride = git.env['HOME'] // Sanity check
|
|
expect(homeOverride).toBeTruthy()
|
|
await fs.promises.stat(path.join(git.env['HOME'], '.gitconfig'))
|
|
|
|
// Act
|
|
await authHelper.removeGlobalConfig()
|
|
|
|
// Assert
|
|
expect(git.env['HOME']).toBeUndefined()
|
|
try {
|
|
await fs.promises.stat(homeOverride)
|
|
throw new Error(`Should have been deleted '${homeOverride}'`)
|
|
} catch (err) {
|
|
if ((err as any)?.code !== 'ENOENT') {
|
|
throw err
|
|
}
|
|
}
|
|
})
|
|
})
|
|
|
|
async function setup(testName: string): Promise<void> {
|
|
testName = testName.replace(/[^a-zA-Z0-9_]+/g, '-')
|
|
|
|
// Directories
|
|
workspace = path.join(testWorkspace, testName, 'workspace')
|
|
runnerTemp = path.join(testWorkspace, testName, 'runner-temp')
|
|
tempHomedir = path.join(testWorkspace, testName, 'home-dir')
|
|
await fs.promises.mkdir(workspace, {recursive: true})
|
|
await fs.promises.mkdir(runnerTemp, {recursive: true})
|
|
await fs.promises.mkdir(tempHomedir, {recursive: true})
|
|
process.env['RUNNER_TEMP'] = runnerTemp
|
|
process.env['HOME'] = tempHomedir
|
|
|
|
// Create git config
|
|
globalGitConfigPath = path.join(tempHomedir, '.gitconfig')
|
|
await fs.promises.writeFile(globalGitConfigPath, '')
|
|
localGitConfigPath = path.join(workspace, '.git', 'config')
|
|
await fs.promises.mkdir(path.dirname(localGitConfigPath), {recursive: true})
|
|
await fs.promises.writeFile(localGitConfigPath, '')
|
|
|
|
git = {
|
|
branchDelete: jest.fn(),
|
|
branchExists: jest.fn(),
|
|
branchList: jest.fn(),
|
|
checkout: jest.fn(),
|
|
checkoutDetach: jest.fn(),
|
|
config: jest.fn(
|
|
async (key: string, value: string, globalConfig?: boolean) => {
|
|
const configPath = globalConfig
|
|
? path.join(git.env['HOME'] || tempHomedir, '.gitconfig')
|
|
: localGitConfigPath
|
|
await fs.promises.appendFile(configPath, `\n${key} ${value}`)
|
|
}
|
|
),
|
|
configExists: jest.fn(
|
|
async (key: string, globalConfig?: boolean): Promise<boolean> => {
|
|
const configPath = globalConfig
|
|
? path.join(git.env['HOME'] || tempHomedir, '.gitconfig')
|
|
: localGitConfigPath
|
|
const content = await fs.promises.readFile(configPath)
|
|
const lines = content
|
|
.toString()
|
|
.split('\n')
|
|
.filter(x => x)
|
|
return lines.some(x => x.startsWith(key))
|
|
}
|
|
),
|
|
env: {},
|
|
fetch: jest.fn(),
|
|
getDefaultBranch: jest.fn(),
|
|
getWorkingDirectory: jest.fn(() => workspace),
|
|
init: jest.fn(),
|
|
isDetached: jest.fn(),
|
|
lfsFetch: jest.fn(),
|
|
lfsInstall: jest.fn(),
|
|
log1: jest.fn(),
|
|
remoteAdd: jest.fn(),
|
|
removeEnvironmentVariable: jest.fn((name: string) => delete git.env[name]),
|
|
revParse: jest.fn(),
|
|
setEnvironmentVariable: jest.fn((name: string, value: string) => {
|
|
git.env[name] = value
|
|
}),
|
|
shaExists: jest.fn(),
|
|
submoduleForeach: jest.fn(async () => {
|
|
return ''
|
|
}),
|
|
submoduleSync: jest.fn(),
|
|
submoduleUpdate: jest.fn(),
|
|
tagExists: jest.fn(),
|
|
tryClean: jest.fn(),
|
|
tryConfigUnset: jest.fn(
|
|
async (key: string, globalConfig?: boolean): Promise<boolean> => {
|
|
const configPath = globalConfig
|
|
? path.join(git.env['HOME'] || tempHomedir, '.gitconfig')
|
|
: localGitConfigPath
|
|
let content = await fs.promises.readFile(configPath)
|
|
let lines = content
|
|
.toString()
|
|
.split('\n')
|
|
.filter(x => x)
|
|
.filter(x => !x.startsWith(key))
|
|
await fs.promises.writeFile(configPath, lines.join('\n'))
|
|
return true
|
|
}
|
|
),
|
|
tryDisableAutomaticGarbageCollection: jest.fn(),
|
|
tryGetFetchUrl: jest.fn(),
|
|
tryReset: jest.fn()
|
|
}
|
|
|
|
settings = {
|
|
authToken: 'some auth token',
|
|
clean: true,
|
|
commit: '',
|
|
fetchDepth: 1,
|
|
lfs: false,
|
|
submodules: false,
|
|
nestedSubmodules: false,
|
|
persistCredentials: true,
|
|
ref: 'refs/heads/main',
|
|
repositoryName: 'my-repo',
|
|
repositoryOwner: 'my-org',
|
|
repositoryPath: '',
|
|
sshKey: sshPath ? 'some ssh private key' : '',
|
|
sshKnownHosts: '',
|
|
sshStrict: true,
|
|
workflowOrganizationId: 123456,
|
|
setSafeDirectory: true,
|
|
githubServerUrl: githubServerUrl
|
|
}
|
|
}
|
|
|
|
async function getActualSshKeyPath(): Promise<string> {
|
|
let actualTempFiles = (await fs.promises.readdir(runnerTemp))
|
|
.sort()
|
|
.map(x => path.join(runnerTemp, x))
|
|
if (actualTempFiles.length === 0) {
|
|
return ''
|
|
}
|
|
|
|
expect(actualTempFiles).toHaveLength(2)
|
|
expect(actualTempFiles[0].endsWith('_known_hosts')).toBeFalsy()
|
|
return actualTempFiles[0]
|
|
}
|
|
|
|
async function getActualSshKnownHostsPath(): Promise<string> {
|
|
let actualTempFiles = (await fs.promises.readdir(runnerTemp))
|
|
.sort()
|
|
.map(x => path.join(runnerTemp, x))
|
|
if (actualTempFiles.length === 0) {
|
|
return ''
|
|
}
|
|
|
|
expect(actualTempFiles).toHaveLength(2)
|
|
expect(actualTempFiles[1].endsWith('_known_hosts')).toBeTruthy()
|
|
expect(actualTempFiles[1].startsWith(actualTempFiles[0])).toBeTruthy()
|
|
return actualTempFiles[1]
|
|
}
|