mirror of
https://github.com/renovatebot/renovate.git
synced 2025-01-15 17:16:25 +00:00
897 lines
26 KiB
TypeScript
897 lines
26 KiB
TypeScript
import is from '@sindresorhus/is';
|
|
import * as _hostRules from '../../util/host-rules';
|
|
import { RepoParams, Platform } from '../common';
|
|
import { REPOSITORY_DISABLED } from '../../constants/error-messages';
|
|
import {
|
|
BRANCH_STATUS_FAILED,
|
|
BRANCH_STATUS_PENDING,
|
|
BRANCH_STATUS_SUCCESS,
|
|
} from '../../constants/branch-constants';
|
|
|
|
describe('platform/azure', () => {
|
|
let hostRules: jest.Mocked<typeof _hostRules>;
|
|
let azure: Platform;
|
|
let azureApi: jest.Mocked<typeof import('./azure-got-wrapper')>;
|
|
let azureHelper: jest.Mocked<typeof import('./azure-helper')>;
|
|
let GitStorage;
|
|
beforeEach(async () => {
|
|
// reset module
|
|
jest.resetModules();
|
|
jest.mock('./azure-got-wrapper');
|
|
jest.mock('./azure-helper');
|
|
jest.mock('../git/storage');
|
|
jest.mock('../../util/host-rules');
|
|
hostRules = require('../../util/host-rules');
|
|
require('../../util/sanitize').sanitize = jest.fn(input => input);
|
|
azure = await import('.');
|
|
azureApi = require('./azure-got-wrapper');
|
|
azureHelper = require('./azure-helper');
|
|
GitStorage = require('../git/storage').Storage;
|
|
GitStorage.mockImplementation(() => ({
|
|
initRepo: jest.fn(),
|
|
cleanRepo: jest.fn(),
|
|
getFileList: jest.fn(),
|
|
branchExists: jest.fn(() => true),
|
|
isBranchStale: jest.fn(() => false),
|
|
setBaseBranch: jest.fn(),
|
|
getBranchLastCommitTime: jest.fn(),
|
|
getAllRenovateBranches: jest.fn(),
|
|
getCommitMessages: jest.fn(),
|
|
getFile: jest.fn(),
|
|
commitFilesToBranch: jest.fn(),
|
|
mergeBranch: jest.fn(),
|
|
deleteBranch: jest.fn(),
|
|
getRepoStatus: jest.fn(),
|
|
}));
|
|
hostRules.find.mockReturnValue({
|
|
token: 'token',
|
|
});
|
|
await azure.initPlatform({
|
|
endpoint: 'https://dev.azure.com/renovate12345',
|
|
token: 'token',
|
|
});
|
|
});
|
|
|
|
afterEach(() => {
|
|
azure.cleanRepo();
|
|
});
|
|
|
|
// do we need the args?
|
|
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
|
function getRepos(_token: string, _endpoint: string) {
|
|
azureApi.gitApi.mockImplementationOnce(
|
|
() =>
|
|
({
|
|
getRepositories: jest.fn(() => [
|
|
{
|
|
name: 'repo1',
|
|
project: {
|
|
name: 'prj1',
|
|
},
|
|
},
|
|
{
|
|
name: 'repo2',
|
|
project: {
|
|
name: 'prj1',
|
|
},
|
|
},
|
|
]),
|
|
} as any)
|
|
);
|
|
return azure.getRepos();
|
|
}
|
|
|
|
describe('initPlatform()', () => {
|
|
it('should throw if no endpoint', () => {
|
|
expect.assertions(1);
|
|
expect(() => azure.initPlatform({})).toThrow();
|
|
});
|
|
it('should throw if no token', () => {
|
|
expect.assertions(1);
|
|
expect(() =>
|
|
azure.initPlatform({
|
|
endpoint: 'https://dev.azure.com/renovate12345',
|
|
})
|
|
).toThrow();
|
|
});
|
|
it('should init', async () => {
|
|
expect(
|
|
await azure.initPlatform({
|
|
endpoint: 'https://dev.azure.com/renovate12345',
|
|
token: 'token',
|
|
})
|
|
).toMatchSnapshot();
|
|
});
|
|
});
|
|
|
|
describe('getRepos()', () => {
|
|
it('should return an array of repos', async () => {
|
|
const repos = await getRepos(
|
|
'sometoken',
|
|
'https://dev.azure.com/renovate12345'
|
|
);
|
|
expect(azureApi.gitApi.mock.calls).toMatchSnapshot();
|
|
expect(repos).toMatchSnapshot();
|
|
});
|
|
});
|
|
|
|
function initRepo(args?: Partial<RepoParams> | string) {
|
|
azureApi.gitApi.mockImplementationOnce(
|
|
() =>
|
|
({
|
|
getRepositories: jest.fn(() => [
|
|
{
|
|
name: 'some-repo',
|
|
id: '1',
|
|
privateRepo: true,
|
|
isFork: false,
|
|
defaultBranch: 'defBr',
|
|
project: {
|
|
name: 'some-repo',
|
|
},
|
|
},
|
|
{
|
|
name: 'repo2',
|
|
project: {
|
|
name: 'prj2',
|
|
},
|
|
},
|
|
]),
|
|
} as any)
|
|
);
|
|
azureApi.gitApi.mockImplementationOnce(
|
|
() =>
|
|
({
|
|
getBranch: jest.fn(() => ({ commit: { commitId: '1234' } })),
|
|
} as any)
|
|
);
|
|
azureHelper.getProjectAndRepo.mockImplementationOnce(() => ({
|
|
project: 'some-repo',
|
|
repo: 'some-repo',
|
|
}));
|
|
|
|
if (is.string(args)) {
|
|
return azure.initRepo({
|
|
repository: args,
|
|
} as any);
|
|
}
|
|
|
|
return azure.initRepo({
|
|
repository: 'some/repo',
|
|
...args,
|
|
} as any);
|
|
}
|
|
|
|
describe('getRepoStatus()', () => {
|
|
it('exists', async () => {
|
|
await initRepo();
|
|
expect(await azure.getRepoStatus()).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
describe('cleanRepo()', () => {
|
|
it('exists', async () => {
|
|
await azure.cleanRepo();
|
|
});
|
|
});
|
|
|
|
describe('initRepo', () => {
|
|
it(`should initialise the config for a repo`, async () => {
|
|
const config = await initRepo({
|
|
repository: 'some-repo',
|
|
});
|
|
expect(azureApi.gitApi.mock.calls).toMatchSnapshot();
|
|
expect(config).toMatchSnapshot();
|
|
});
|
|
|
|
it('throws disabled', async () => {
|
|
expect.assertions(1);
|
|
azureHelper.getFile.mockResolvedValueOnce('{ "enabled": false }');
|
|
await expect(
|
|
initRepo({ repository: 'some-repo', optimizeForDisabled: true })
|
|
).rejects.toThrow(REPOSITORY_DISABLED);
|
|
});
|
|
});
|
|
|
|
describe('getRepoForceRebase', () => {
|
|
it('should return false', async () => {
|
|
expect(await azure.getRepoForceRebase()).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe('findPr(branchName, prTitle, state)', () => {
|
|
it('returns pr if found it open', async () => {
|
|
azureApi.gitApi.mockImplementationOnce(
|
|
() =>
|
|
({
|
|
getPullRequests: jest
|
|
.fn()
|
|
.mockReturnValue([])
|
|
.mockReturnValueOnce([
|
|
{
|
|
pullRequestId: 1,
|
|
sourceRefName: 'refs/heads/branch-a',
|
|
title: 'branch a pr',
|
|
state: 'open',
|
|
},
|
|
]),
|
|
getPullRequestCommits: jest.fn().mockReturnValue([]),
|
|
} as any)
|
|
);
|
|
azureHelper.getNewBranchName.mockImplementationOnce(
|
|
() => 'refs/heads/branch-a'
|
|
);
|
|
azureHelper.getRenovatePRFormat.mockImplementationOnce(
|
|
() =>
|
|
({
|
|
number: 1,
|
|
sourceRefName: 'refs/heads/branch-a',
|
|
title: 'branch a pr',
|
|
state: 'open',
|
|
} as any)
|
|
);
|
|
const res = await azure.findPr({
|
|
branchName: 'branch-a',
|
|
prTitle: 'branch a pr',
|
|
state: 'open',
|
|
});
|
|
expect(res).toMatchSnapshot();
|
|
});
|
|
it('returns pr if found not open', async () => {
|
|
azureApi.gitApi.mockImplementationOnce(
|
|
() =>
|
|
({
|
|
getPullRequests: jest
|
|
.fn()
|
|
.mockReturnValue([])
|
|
.mockReturnValueOnce([
|
|
{
|
|
pullRequestId: 1,
|
|
sourceRefName: 'refs/heads/branch-a',
|
|
title: 'branch a pr',
|
|
state: 'closed',
|
|
},
|
|
]),
|
|
getPullRequestCommits: jest.fn().mockReturnValue([]),
|
|
} as any)
|
|
);
|
|
azureHelper.getNewBranchName.mockImplementationOnce(
|
|
() => 'refs/heads/branch-a'
|
|
);
|
|
azureHelper.getRenovatePRFormat.mockImplementationOnce(
|
|
() =>
|
|
({
|
|
number: 1,
|
|
sourceRefName: 'refs/heads/branch-a',
|
|
title: 'branch a pr',
|
|
state: 'closed',
|
|
} as any)
|
|
);
|
|
const res = await azure.findPr({
|
|
branchName: 'branch-a',
|
|
prTitle: 'branch a pr',
|
|
state: '!open',
|
|
});
|
|
expect(res).toMatchSnapshot();
|
|
});
|
|
it('returns pr if found it close', async () => {
|
|
azureApi.gitApi.mockImplementationOnce(
|
|
() =>
|
|
({
|
|
getPullRequests: jest
|
|
.fn()
|
|
.mockReturnValue([])
|
|
.mockReturnValueOnce([
|
|
{
|
|
pullRequestId: 1,
|
|
sourceRefName: 'refs/heads/branch-a',
|
|
title: 'branch a pr',
|
|
state: 'closed',
|
|
},
|
|
]),
|
|
getPullRequestCommits: jest.fn().mockReturnValue([]),
|
|
} as any)
|
|
);
|
|
azureHelper.getNewBranchName.mockImplementationOnce(
|
|
() => 'refs/heads/branch-a'
|
|
);
|
|
azureHelper.getRenovatePRFormat.mockImplementationOnce(
|
|
() =>
|
|
({
|
|
number: 1,
|
|
sourceRefName: 'refs/heads/branch-a',
|
|
title: 'branch a pr',
|
|
state: 'closed',
|
|
} as any)
|
|
);
|
|
const res = await azure.findPr({
|
|
branchName: 'branch-a',
|
|
prTitle: 'branch a pr',
|
|
state: 'closed',
|
|
});
|
|
expect(res).toMatchSnapshot();
|
|
});
|
|
it('returns pr if found it all state', async () => {
|
|
azureApi.gitApi.mockImplementationOnce(
|
|
() =>
|
|
({
|
|
getPullRequests: jest
|
|
.fn()
|
|
.mockReturnValue([])
|
|
.mockReturnValueOnce([
|
|
{
|
|
pullRequestId: 1,
|
|
sourceRefName: 'refs/heads/branch-a',
|
|
title: 'branch a pr',
|
|
state: 'closed',
|
|
},
|
|
]),
|
|
getPullRequestCommits: jest.fn().mockReturnValue([]),
|
|
} as any)
|
|
);
|
|
azureHelper.getNewBranchName.mockImplementationOnce(
|
|
() => 'refs/heads/branch-a'
|
|
);
|
|
azureHelper.getRenovatePRFormat.mockImplementationOnce(
|
|
() =>
|
|
({
|
|
number: 1,
|
|
sourceRefName: 'refs/heads/branch-a',
|
|
title: 'branch a pr',
|
|
state: 'closed',
|
|
} as any)
|
|
);
|
|
const res = await azure.findPr({
|
|
branchName: 'branch-a',
|
|
prTitle: 'branch a pr',
|
|
});
|
|
expect(res).toMatchSnapshot();
|
|
});
|
|
});
|
|
describe('getPrList()', () => {
|
|
it('returns empty array', async () => {
|
|
azureApi.gitApi.mockImplementationOnce(
|
|
() =>
|
|
({
|
|
getPullRequests: jest.fn(() => []),
|
|
} as any)
|
|
);
|
|
expect(await azure.getPrList()).toEqual([]);
|
|
});
|
|
});
|
|
|
|
describe('getBranchPr(branchName)', () => {
|
|
it('should return null if no PR exists', async () => {
|
|
await initRepo({ repository: 'some/repo' });
|
|
azureApi.gitApi.mockImplementationOnce(
|
|
() =>
|
|
({
|
|
findPr: jest.fn(() => false),
|
|
getPr: jest.fn(() => {
|
|
'myPRName';
|
|
}),
|
|
} as any)
|
|
);
|
|
const pr = await azure.getBranchPr('somebranch');
|
|
expect(pr).toBeNull();
|
|
});
|
|
it('should return the pr', async () => {
|
|
await initRepo({ repository: 'some/repo' });
|
|
azureApi.gitApi.mockImplementation(
|
|
() =>
|
|
({
|
|
getPullRequests: jest
|
|
.fn()
|
|
.mockReturnValue([])
|
|
.mockReturnValueOnce([
|
|
{
|
|
pullRequestId: 1,
|
|
sourceRefName: 'refs/heads/branch-a',
|
|
title: 'branch a pr',
|
|
status: 2,
|
|
},
|
|
]),
|
|
getPullRequestCommits: jest.fn().mockReturnValue([]),
|
|
} as any)
|
|
);
|
|
azureHelper.getNewBranchName.mockImplementation(
|
|
() => 'refs/heads/branch-a'
|
|
);
|
|
azureHelper.getRenovatePRFormat.mockImplementation(
|
|
() =>
|
|
({
|
|
pullRequestId: 1,
|
|
number: 1,
|
|
head: { ref: 'branch-a' },
|
|
title: 'branch a pr',
|
|
isClosed: false,
|
|
} as any)
|
|
);
|
|
const pr = await azure.getBranchPr('somebranch');
|
|
expect(pr).toMatchSnapshot();
|
|
});
|
|
});
|
|
|
|
describe('getBranchStatus(branchName, requiredStatusChecks)', () => {
|
|
it('return success if requiredStatusChecks null', async () => {
|
|
await initRepo('some-repo');
|
|
const res = await azure.getBranchStatus('somebranch', null);
|
|
expect(res).toEqual(BRANCH_STATUS_SUCCESS);
|
|
});
|
|
it('return failed if unsupported requiredStatusChecks', async () => {
|
|
await initRepo('some-repo');
|
|
const res = await azure.getBranchStatus('somebranch', ['foo']);
|
|
expect(res).toEqual(BRANCH_STATUS_FAILED);
|
|
});
|
|
it('should pass through success', async () => {
|
|
await initRepo({ repository: 'some/repo' });
|
|
azureApi.gitApi.mockImplementationOnce(
|
|
() =>
|
|
({
|
|
getBranch: jest.fn(() => ({ aheadCount: 0 })),
|
|
} as any)
|
|
);
|
|
const res = await azure.getBranchStatus('somebranch', []);
|
|
expect(res).toEqual(BRANCH_STATUS_SUCCESS);
|
|
});
|
|
it('should pass through failed', async () => {
|
|
await initRepo({ repository: 'some/repo' });
|
|
azureApi.gitApi.mockImplementationOnce(
|
|
() =>
|
|
({
|
|
getBranch: jest.fn(() => ({ aheadCount: 123 })),
|
|
} as any)
|
|
);
|
|
const res = await azure.getBranchStatus('somebranch', []);
|
|
expect(res).toEqual(BRANCH_STATUS_PENDING);
|
|
});
|
|
});
|
|
|
|
describe('getPr(prNo)', () => {
|
|
it('should return null if no prNo is passed', async () => {
|
|
const pr = await azure.getPr(0);
|
|
expect(pr).toBeNull();
|
|
});
|
|
it('should return null if no PR is returned from azure', async () => {
|
|
await initRepo({ repository: 'some/repo' });
|
|
azureApi.gitApi.mockImplementationOnce(
|
|
() =>
|
|
({
|
|
getPullRequests: jest.fn(() => []),
|
|
} as any)
|
|
);
|
|
const pr = await azure.getPr(1234);
|
|
expect(pr).toBeNull();
|
|
});
|
|
it('should return a pr in the right format', async () => {
|
|
await initRepo({ repository: 'some/repo' });
|
|
azureApi.gitApi.mockImplementation(
|
|
() =>
|
|
({
|
|
getPullRequests: jest
|
|
.fn()
|
|
.mockReturnValue([])
|
|
.mockReturnValueOnce([
|
|
{
|
|
pullRequestId: 1234,
|
|
},
|
|
]),
|
|
getPullRequestLabels: jest
|
|
.fn()
|
|
.mockReturnValue([{ active: true, name: 'renovate' }]),
|
|
getPullRequestCommits: jest.fn().mockReturnValue([
|
|
{
|
|
author: {
|
|
name: 'renovate',
|
|
},
|
|
},
|
|
]),
|
|
} as any)
|
|
);
|
|
azureHelper.getRenovatePRFormat.mockImplementation(
|
|
() =>
|
|
({
|
|
pullRequestId: 1234,
|
|
} as any)
|
|
);
|
|
const pr = await azure.getPr(1234);
|
|
expect(pr).toMatchSnapshot();
|
|
});
|
|
it('should return a pr thats been modified', async () => {
|
|
await initRepo({ repository: 'some/repo' });
|
|
azureApi.gitApi.mockImplementation(
|
|
() =>
|
|
({
|
|
getPullRequests: jest
|
|
.fn()
|
|
.mockReturnValue([])
|
|
.mockReturnValueOnce([
|
|
{
|
|
pullRequestId: 1234,
|
|
},
|
|
]),
|
|
getPullRequestLabels: jest.fn().mockReturnValue([]),
|
|
getPullRequestCommits: jest.fn().mockReturnValue([
|
|
{
|
|
author: {
|
|
name: 'renovate',
|
|
},
|
|
},
|
|
{
|
|
author: {
|
|
name: 'end user',
|
|
},
|
|
},
|
|
]),
|
|
} as any)
|
|
);
|
|
azureHelper.getRenovatePRFormat.mockImplementation(
|
|
() =>
|
|
({
|
|
pullRequestId: 1234,
|
|
isModified: false,
|
|
} as any)
|
|
);
|
|
const pr = await azure.getPr(1234);
|
|
expect(pr).toMatchSnapshot();
|
|
});
|
|
});
|
|
|
|
describe('createPr()', () => {
|
|
it('should create and return a PR object', async () => {
|
|
await initRepo({ repository: 'some/repo' });
|
|
azureApi.gitApi.mockImplementationOnce(
|
|
() =>
|
|
({
|
|
createPullRequest: jest.fn(() => ({
|
|
pullRequestId: 456,
|
|
displayNumber: `Pull Request #456`,
|
|
})),
|
|
createPullRequestLabel: jest.fn(() => ({})),
|
|
} as any)
|
|
);
|
|
azureHelper.getRenovatePRFormat.mockImplementation(
|
|
() =>
|
|
({
|
|
displayNumber: 'Pull Request #456',
|
|
number: 456,
|
|
pullRequestId: 456,
|
|
} as any)
|
|
);
|
|
const pr = await azure.createPr({
|
|
branchName: 'some-branch',
|
|
prTitle: 'The Title',
|
|
prBody: 'Hello world',
|
|
labels: ['deps', 'renovate'],
|
|
});
|
|
expect(pr).toMatchSnapshot();
|
|
});
|
|
it('should create and return a PR object from base branch', async () => {
|
|
await initRepo({ repository: 'some/repo' });
|
|
azureApi.gitApi.mockImplementationOnce(
|
|
() =>
|
|
({
|
|
createPullRequest: jest.fn(() => ({
|
|
pullRequestId: 456,
|
|
displayNumber: `Pull Request #456`,
|
|
})),
|
|
createPullRequestLabel: jest.fn(() => ({})),
|
|
} as any)
|
|
);
|
|
azureHelper.getRenovatePRFormat.mockImplementation(
|
|
() =>
|
|
({
|
|
displayNumber: 'Pull Request #456',
|
|
number: 456,
|
|
pullRequestId: 456,
|
|
} as any)
|
|
);
|
|
const pr = await azure.createPr({
|
|
branchName: 'some-branch',
|
|
prTitle: 'The Title',
|
|
prBody: 'Hello world',
|
|
labels: ['deps', 'renovate'],
|
|
useDefaultBranch: true,
|
|
});
|
|
expect(pr).toMatchSnapshot();
|
|
});
|
|
it('should create and return a PR object with auto-complete set', async () => {
|
|
await initRepo({ repository: 'some/repo' });
|
|
const prResult = {
|
|
pullRequestId: 456,
|
|
displayNumber: `Pull Request #456`,
|
|
createdBy: {
|
|
id: 123,
|
|
},
|
|
};
|
|
const prUpdateResult = {
|
|
...prResult,
|
|
autoCompleteSetBy: {
|
|
id: prResult.createdBy.id,
|
|
},
|
|
completionOptions: {
|
|
squashMerge: true,
|
|
deleteSourceBranch: true,
|
|
},
|
|
};
|
|
const updateFn = jest
|
|
.fn(() => prUpdateResult)
|
|
.mockName('updatePullRequest');
|
|
azureApi.gitApi.mockImplementationOnce(
|
|
() =>
|
|
({
|
|
createPullRequest: jest.fn(() => prResult),
|
|
createPullRequestLabel: jest.fn(() => ({})),
|
|
updatePullRequest: updateFn,
|
|
} as any)
|
|
);
|
|
azureHelper.getRenovatePRFormat.mockImplementation(x => x as any);
|
|
const pr = await azure.createPr({
|
|
branchName: 'some-branch',
|
|
prTitle: 'The Title',
|
|
prBody: 'Hello world',
|
|
labels: ['deps', 'renovate'],
|
|
useDefaultBranch: false,
|
|
platformOptions: { azureAutoComplete: true },
|
|
});
|
|
expect(updateFn).toHaveBeenCalled();
|
|
expect(pr).toMatchSnapshot();
|
|
});
|
|
});
|
|
|
|
describe('updatePr(prNo, title, body)', () => {
|
|
it('should update the PR', async () => {
|
|
await initRepo({ repository: 'some/repo' });
|
|
const updatePullRequest = jest.fn();
|
|
azureApi.gitApi.mockImplementationOnce(
|
|
() =>
|
|
({
|
|
updatePullRequest,
|
|
} as any)
|
|
);
|
|
await azure.updatePr(1234, 'The New Title', 'Hello world again');
|
|
expect(updatePullRequest.mock.calls).toMatchSnapshot();
|
|
});
|
|
|
|
it('should update the PR without description', async () => {
|
|
await initRepo({ repository: 'some/repo' });
|
|
const updatePullRequest = jest.fn();
|
|
azureApi.gitApi.mockImplementationOnce(
|
|
() =>
|
|
({
|
|
updatePullRequest,
|
|
} as any)
|
|
);
|
|
await azure.updatePr(1234, 'The New Title - autoclose');
|
|
expect(updatePullRequest.mock.calls).toMatchSnapshot();
|
|
});
|
|
});
|
|
|
|
describe('ensureComment', () => {
|
|
it('adds comment if missing', async () => {
|
|
await initRepo({ repository: 'some/repo' });
|
|
const gitApiMock = {
|
|
createThread: jest.fn(() => [{ id: 123 }]),
|
|
getThreads: jest.fn().mockReturnValue([
|
|
{
|
|
comments: [{ content: 'end-user comment', id: 1 }],
|
|
id: 2,
|
|
},
|
|
]),
|
|
updateComment: jest.fn(() => ({ id: 123 })),
|
|
};
|
|
azureApi.gitApi.mockImplementation(() => gitApiMock as any);
|
|
await azure.ensureComment({
|
|
number: 42,
|
|
topic: 'some-subject',
|
|
content: 'some\ncontent',
|
|
});
|
|
expect(gitApiMock.createThread.mock.calls).toMatchSnapshot();
|
|
expect(gitApiMock.updateComment.mock.calls).toMatchSnapshot();
|
|
});
|
|
it('updates comment if missing', async () => {
|
|
await initRepo({ repository: 'some/repo' });
|
|
const gitApiMock = {
|
|
createThread: jest.fn(() => [{ id: 123 }]),
|
|
getThreads: jest.fn().mockReturnValue([
|
|
{
|
|
comments: [{ content: 'end-user comment', id: 1 }],
|
|
id: 3,
|
|
},
|
|
{
|
|
comments: [{ content: '### some-subject\n\nsome\ncontent', id: 2 }],
|
|
id: 4,
|
|
},
|
|
]),
|
|
updateComment: jest.fn(() => ({ id: 123 })),
|
|
};
|
|
azureApi.gitApi.mockImplementation(() => gitApiMock as any);
|
|
await azure.ensureComment({
|
|
number: 42,
|
|
topic: 'some-subject',
|
|
content: 'some\nnew\ncontent',
|
|
});
|
|
expect(gitApiMock.createThread.mock.calls).toMatchSnapshot();
|
|
expect(gitApiMock.updateComment.mock.calls).toMatchSnapshot();
|
|
});
|
|
it('does nothing if comment exists and is the same', async () => {
|
|
await initRepo({ repository: 'some/repo' });
|
|
const gitApiMock = {
|
|
createThread: jest.fn(() => [{ id: 123 }]),
|
|
getThreads: jest.fn().mockReturnValue([
|
|
{
|
|
comments: [{ content: 'end-user comment', id: 1 }],
|
|
id: 3,
|
|
},
|
|
{
|
|
comments: [{ content: '### some-subject\n\nsome\ncontent', id: 2 }],
|
|
id: 4,
|
|
},
|
|
]),
|
|
updateComment: jest.fn(() => ({ id: 123 })),
|
|
};
|
|
azureApi.gitApi.mockImplementation(() => gitApiMock as any);
|
|
await azure.ensureComment({
|
|
number: 42,
|
|
topic: 'some-subject',
|
|
content: 'some\ncontent',
|
|
});
|
|
expect(gitApiMock.createThread.mock.calls).toMatchSnapshot();
|
|
expect(gitApiMock.updateComment.mock.calls).toMatchSnapshot();
|
|
});
|
|
it('does nothing if comment exists and is the same when there is no topic', async () => {
|
|
await initRepo({ repository: 'some/repo' });
|
|
const gitApiMock = {
|
|
createThread: jest.fn(() => [{ id: 123 }]),
|
|
getThreads: jest.fn().mockReturnValue([
|
|
{
|
|
comments: [{ content: 'some\ncontent', id: 2 }],
|
|
id: 4,
|
|
},
|
|
]),
|
|
updateComment: jest.fn(() => ({ id: 123 })),
|
|
};
|
|
azureApi.gitApi.mockImplementation(() => gitApiMock as any);
|
|
await azure.ensureComment({
|
|
number: 42,
|
|
topic: null,
|
|
content: 'some\ncontent',
|
|
});
|
|
expect(gitApiMock.createThread.mock.calls).toMatchSnapshot();
|
|
expect(gitApiMock.updateComment.mock.calls).toMatchSnapshot();
|
|
});
|
|
});
|
|
|
|
describe('ensureCommentRemoval', () => {
|
|
it('deletes comment if found', async () => {
|
|
await initRepo({ repository: 'some/repo' });
|
|
azureApi.gitApi.mockImplementation(
|
|
() =>
|
|
({
|
|
getThreads: jest.fn(() => [
|
|
{
|
|
comments: [{ content: '### some-subject\n\nblabla' }],
|
|
id: 123,
|
|
},
|
|
]),
|
|
updateThread: jest.fn(),
|
|
} as any)
|
|
);
|
|
await azure.ensureCommentRemoval(42, 'some-subject');
|
|
expect(azureApi.gitApi).toHaveBeenCalledTimes(3);
|
|
});
|
|
it('nothing should happen, no number', async () => {
|
|
await azure.ensureCommentRemoval(0, 'test');
|
|
expect(azureApi.gitApi).toHaveBeenCalledTimes(0);
|
|
});
|
|
it('comment not found', async () => {
|
|
await initRepo({ repository: 'some/repo' });
|
|
azureApi.gitApi.mockImplementation(
|
|
() =>
|
|
({
|
|
getThreads: jest.fn(() => [
|
|
{ comments: [{ content: 'stupid comment' }], id: 123 },
|
|
]),
|
|
updateThread: jest.fn(),
|
|
} as any)
|
|
);
|
|
await azure.ensureCommentRemoval(42, 'some-subject');
|
|
expect(azureApi.gitApi).toHaveBeenCalledTimes(3);
|
|
});
|
|
});
|
|
|
|
describe('Assignees', () => {
|
|
it('addAssignees', async () => {
|
|
await initRepo({ repository: 'some/repo' });
|
|
azureApi.gitApi.mockImplementation(
|
|
() =>
|
|
({
|
|
createThread: jest.fn(() => [{ id: 123 }]),
|
|
getThreads: jest.fn(() => []),
|
|
} as any)
|
|
);
|
|
await azure.addAssignees(123, ['test@bonjour.fr']);
|
|
expect(azureApi.gitApi).toHaveBeenCalledTimes(3);
|
|
});
|
|
});
|
|
|
|
describe('Reviewers', () => {
|
|
it('addReviewers', async () => {
|
|
await initRepo({ repository: 'some/repo' });
|
|
azureApi.gitApi.mockImplementation(
|
|
() =>
|
|
({
|
|
getRepositories: jest.fn(() => [{ id: '1', project: { id: 2 } }]),
|
|
createPullRequestReviewer: jest.fn(),
|
|
} as any)
|
|
);
|
|
azureApi.coreApi.mockImplementation(
|
|
() =>
|
|
({
|
|
getTeams: jest.fn(() => [
|
|
{ id: 3, name: 'abc' },
|
|
{ id: 4, name: 'def' },
|
|
]),
|
|
getTeamMembersWithExtendedProperties: jest.fn(() => [
|
|
{ identity: { displayName: 'jyc', uniqueName: 'jyc', id: 123 } },
|
|
]),
|
|
} as any)
|
|
);
|
|
await azure.addReviewers(123, ['test@bonjour.fr', 'jyc', 'def']);
|
|
expect(azureApi.gitApi).toHaveBeenCalledTimes(3);
|
|
});
|
|
});
|
|
|
|
describe('getPrBody(input)', () => {
|
|
it('returns updated pr body', () => {
|
|
const input =
|
|
'<details>https://github.com/foo/bar/issues/5 plus also [a link](https://github.com/foo/bar/issues/5)';
|
|
expect(azure.getPrBody(input)).toMatchSnapshot();
|
|
});
|
|
});
|
|
|
|
describe('Not supported by Azure DevOps (yet!)', () => {
|
|
it('setBranchStatus', async () => {
|
|
const res = await azure.setBranchStatus({
|
|
branchName: 'test',
|
|
context: 'test',
|
|
description: 'test',
|
|
state: 'test',
|
|
url: 'test',
|
|
});
|
|
expect(res).toBeUndefined();
|
|
});
|
|
|
|
it('mergePr', async () => {
|
|
const res = await azure.mergePr(0, undefined);
|
|
expect(res).toBe(false);
|
|
});
|
|
|
|
// to become async?
|
|
it('getPrFiles', async () => {
|
|
const res = await azure.getPrFiles(46);
|
|
expect(res).toHaveLength(0);
|
|
});
|
|
});
|
|
|
|
describe('getVulnerabilityAlerts()', () => {
|
|
it('returns empty', async () => {
|
|
const res = await azure.getVulnerabilityAlerts();
|
|
expect(res).toHaveLength(0);
|
|
});
|
|
});
|
|
|
|
describe('deleteLabel()', () => {
|
|
it('Should delete a label', async () => {
|
|
await initRepo({ repository: 'some/repo' });
|
|
azureApi.gitApi.mockImplementationOnce(
|
|
() =>
|
|
({
|
|
deletePullRequestLabels: jest.fn(),
|
|
} as any)
|
|
);
|
|
await azure.deleteLabel(1234, 'rebase');
|
|
expect(azureApi.gitApi.mock.calls).toMatchSnapshot();
|
|
});
|
|
});
|
|
});
|