mirror of
https://github.com/googleapis/release-please-action.git
synced 2026-03-26 06:02:20 +00:00
9cf05a09b1
Any advanced configuration should be done via a release-please-config.json. Fixes #859 Fixes #858 Fixes #857 Fixes #852 feat!: remove most configuration options in favor of manifest configuration to configure the release-please-action refactor!: rewrite in typescript feat!: remove command option in favor of setting `release-type` and `skip-github-release`/`skip-github-pull-request` feat!: run on node20 deps!: upgrade release-please to v16
457 lines
16 KiB
TypeScript
457 lines
16 KiB
TypeScript
// Copyright 2023 Google LLC
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
import {describe, it, beforeEach, afterEach} from 'mocha';
|
|
import * as action from '../src/index';
|
|
import * as assert from 'assert';
|
|
import * as core from '@actions/core';
|
|
import * as sinon from 'sinon';
|
|
import * as nock from 'nock';
|
|
import {RestoreFn} from 'mocked-env';
|
|
import mockedEnv from 'mocked-env';
|
|
|
|
import {Manifest, GitHub} from 'release-please';
|
|
// As defined in action.yml
|
|
|
|
const DEFAULT_INPUTS: Record<string, string> = {
|
|
token: 'fake-token',
|
|
};
|
|
|
|
const fixturePrs = [
|
|
{
|
|
headBranchName: 'release-please--branches--main',
|
|
baseBranchName: 'main',
|
|
number: 22,
|
|
title: 'chore(master): release 1.0.0',
|
|
body: ':robot: I have created a release *beep* *boop*',
|
|
labels: ['autorelease: pending'],
|
|
files: [],
|
|
},
|
|
{
|
|
headBranchName: 'release-please--branches--main',
|
|
baseBranchName: 'main',
|
|
number: 23,
|
|
title: 'chore(master): release 1.0.0',
|
|
body: ':robot: I have created a release *beep* *boop*',
|
|
labels: ['autorelease: pending'],
|
|
files: [],
|
|
},
|
|
];
|
|
|
|
const sandbox = sinon.createSandbox();
|
|
process.env.GITHUB_REPOSITORY = 'fakeOwner/fakeRepo';
|
|
|
|
function mockInputs(inputs: Record<string, string>): RestoreFn {
|
|
const envVars: Record<string, string> = {};
|
|
for (const [name, val] of Object.entries({...DEFAULT_INPUTS, ...inputs})) {
|
|
envVars[`INPUT_${name.replace(/ /g, '_').toUpperCase()}`] = val;
|
|
}
|
|
return mockedEnv(envVars);
|
|
}
|
|
|
|
nock.disableNetConnect();
|
|
|
|
describe('release-please-action', () => {
|
|
let output: Record<string, string | boolean> = {};
|
|
// Save original env varas and restore after each test
|
|
let restoreEnv: RestoreFn | null;
|
|
afterEach(() => {
|
|
sandbox.restore();
|
|
if (restoreEnv) {
|
|
restoreEnv();
|
|
restoreEnv = null;
|
|
}
|
|
});
|
|
beforeEach(() => {
|
|
output = {};
|
|
sandbox.replace(
|
|
core,
|
|
'setOutput',
|
|
(key: string, value: string | boolean) => {
|
|
output[key] = value;
|
|
}
|
|
);
|
|
// Default branch lookup:
|
|
nock('https://api.github.com').get('/repos/fakeOwner/fakeRepo').reply(200, {
|
|
default_branch: 'main',
|
|
});
|
|
});
|
|
afterEach(() => {
|
|
sandbox.restore();
|
|
});
|
|
describe('configuration', () => {
|
|
let fakeManifest: sinon.SinonStubbedInstance<Manifest>;
|
|
describe('with release-type', () => {
|
|
let fromConfigStub: sinon.SinonStub;
|
|
beforeEach(() => {
|
|
fakeManifest = sandbox.createStubInstance(Manifest);
|
|
fromConfigStub = sandbox
|
|
.stub(Manifest, 'fromConfig')
|
|
.resolves(fakeManifest);
|
|
});
|
|
it('builds a manifest from config', async () => {
|
|
restoreEnv = mockInputs({
|
|
'release-type': 'simple',
|
|
});
|
|
fakeManifest.createReleases.resolves([]);
|
|
fakeManifest.createPullRequests.resolves([]);
|
|
await action.main();
|
|
sinon.assert.calledOnce(fakeManifest.createReleases);
|
|
sinon.assert.calledOnce(fakeManifest.createPullRequests);
|
|
});
|
|
it('skips creating releases if skip-github-release specified', async () => {
|
|
restoreEnv = mockInputs({
|
|
'skip-github-release': 'true',
|
|
'release-type': 'simple',
|
|
});
|
|
fakeManifest.createPullRequests.resolves([]);
|
|
await action.main();
|
|
sinon.assert.notCalled(fakeManifest.createReleases);
|
|
sinon.assert.calledOnce(fakeManifest.createPullRequests);
|
|
});
|
|
it('skips creating pull requests if skip-github-pull-request specified', async () => {
|
|
restoreEnv = mockInputs({
|
|
'skip-github-pull-request': 'true',
|
|
'release-type': 'simple',
|
|
});
|
|
fakeManifest.createReleases.resolves([]);
|
|
await action.main();
|
|
sinon.assert.calledOnce(fakeManifest.createReleases);
|
|
sinon.assert.notCalled(fakeManifest.createPullRequests);
|
|
});
|
|
it('allows specifying custom target branch', async () => {
|
|
restoreEnv = mockInputs({
|
|
'target-branch': 'dev',
|
|
'release-type': 'simple',
|
|
});
|
|
fakeManifest.createReleases.resolves([]);
|
|
fakeManifest.createPullRequests.resolves([]);
|
|
await action.main();
|
|
sinon.assert.calledOnce(fakeManifest.createReleases);
|
|
sinon.assert.calledOnce(fakeManifest.createPullRequests);
|
|
|
|
sinon.assert.calledWith(
|
|
fromConfigStub,
|
|
sinon.match.any,
|
|
'dev',
|
|
sinon.match.object,
|
|
sinon.match.object,
|
|
sinon.match.any,
|
|
);
|
|
});
|
|
it('allows specifying fork', async () => {
|
|
restoreEnv = mockInputs({
|
|
'fork': 'true',
|
|
'release-type': 'simple',
|
|
});
|
|
fakeManifest.createReleases.resolves([]);
|
|
fakeManifest.createPullRequests.resolves([]);
|
|
await action.main();
|
|
sinon.assert.calledOnce(fakeManifest.createReleases);
|
|
sinon.assert.calledOnce(fakeManifest.createPullRequests);
|
|
|
|
sinon.assert.calledWith(
|
|
fromConfigStub,
|
|
sinon.match.any,
|
|
sinon.match.string,
|
|
sinon.match.object,
|
|
sinon.match({fork: true}),
|
|
sinon.match.any,
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('with manifest', () => {
|
|
let fromManifestStub: sinon.SinonStub;
|
|
beforeEach(() => {
|
|
fakeManifest = sandbox.createStubInstance(Manifest);
|
|
fromManifestStub = sandbox
|
|
.stub(Manifest, 'fromManifest')
|
|
.resolves(fakeManifest);
|
|
});
|
|
it('loads a manifest from the repository', async () => {
|
|
restoreEnv = mockInputs({});
|
|
fakeManifest.createReleases.resolves([]);
|
|
fakeManifest.createPullRequests.resolves([]);
|
|
await action.main();
|
|
sinon.assert.calledOnce(fakeManifest.createReleases);
|
|
sinon.assert.calledOnce(fakeManifest.createPullRequests);
|
|
});
|
|
it('skips creating releases if skip-github-release specified', async () => {
|
|
restoreEnv = mockInputs({
|
|
'skip-github-release': 'true',
|
|
});
|
|
fakeManifest.createPullRequests.resolves([]);
|
|
await action.main();
|
|
sinon.assert.notCalled(fakeManifest.createReleases);
|
|
sinon.assert.calledOnce(fakeManifest.createPullRequests);
|
|
});
|
|
it('skips creating pull requests if skip-github-pull-request specified', async () => {
|
|
restoreEnv = mockInputs({
|
|
'skip-github-pull-request': 'true',
|
|
});
|
|
fakeManifest.createReleases.resolves([]);
|
|
await action.main();
|
|
sinon.assert.calledOnce(fakeManifest.createReleases);
|
|
sinon.assert.notCalled(fakeManifest.createPullRequests);
|
|
});
|
|
it('allows specifying custom target branch', async () => {
|
|
restoreEnv = mockInputs({
|
|
'target-branch': 'dev',
|
|
});
|
|
fakeManifest.createReleases.resolves([]);
|
|
fakeManifest.createPullRequests.resolves([]);
|
|
await action.main();
|
|
sinon.assert.calledOnce(fakeManifest.createReleases);
|
|
sinon.assert.calledOnce(fakeManifest.createPullRequests);
|
|
|
|
sinon.assert.calledWith(
|
|
fromManifestStub,
|
|
sinon.match.any,
|
|
'dev',
|
|
sinon.match.string,
|
|
sinon.match.string
|
|
);
|
|
});
|
|
it('allows specifying fork', async () => {
|
|
restoreEnv = mockInputs({
|
|
'fork': 'true',
|
|
});
|
|
fakeManifest.createReleases.resolves([]);
|
|
fakeManifest.createPullRequests.resolves([]);
|
|
await action.main();
|
|
sinon.assert.calledOnce(fakeManifest.createReleases);
|
|
sinon.assert.calledOnce(fakeManifest.createPullRequests);
|
|
|
|
sinon.assert.calledWith(
|
|
fromManifestStub,
|
|
sinon.match.any,
|
|
sinon.match.string,
|
|
sinon.match.string,
|
|
sinon.match.string,
|
|
sinon.match({fork: true}),
|
|
);
|
|
});
|
|
});
|
|
|
|
it('allows specifying manifest config paths', async () => {
|
|
restoreEnv = mockInputs({
|
|
'config-file': 'path/to/config.json',
|
|
'manifest-file': 'path/to/manifest.json',
|
|
});
|
|
const fakeManifest = sandbox.createStubInstance(Manifest);
|
|
fakeManifest.createReleases.resolves([]);
|
|
fakeManifest.createPullRequests.resolves([]);
|
|
const fromManifestStub = sandbox
|
|
.stub(Manifest, 'fromManifest')
|
|
.resolves(fakeManifest);
|
|
await action.main();
|
|
sinon.assert.calledOnce(fakeManifest.createReleases);
|
|
sinon.assert.calledOnce(fakeManifest.createPullRequests);
|
|
|
|
sinon.assert.calledWith(
|
|
fromManifestStub,
|
|
sinon.match.any,
|
|
sinon.match.string,
|
|
'path/to/config.json',
|
|
'path/to/manifest.json'
|
|
);
|
|
});
|
|
|
|
it('allows specifying network options', async () => {
|
|
restoreEnv = mockInputs({
|
|
'target-branch': 'dev',
|
|
'proxy-server': 'some-host:9000',
|
|
'github-api-url': 'https://my-enterprise-host.local/api',
|
|
'github-graphql-url': 'https://my-enterprise-host.local/graphql',
|
|
});
|
|
const createGithubSpy = sandbox.spy(GitHub, 'create');
|
|
const fakeManifest = sandbox.createStubInstance(Manifest);
|
|
fakeManifest.createReleases.resolves([]);
|
|
fakeManifest.createPullRequests.resolves([]);
|
|
sandbox.stub(Manifest, 'fromManifest').resolves(fakeManifest);
|
|
await action.main();
|
|
sinon.assert.calledOnce(fakeManifest.createReleases);
|
|
sinon.assert.calledOnce(fakeManifest.createPullRequests);
|
|
|
|
sinon.assert.calledWith(
|
|
createGithubSpy,
|
|
sinon.match({
|
|
apiUrl: 'https://my-enterprise-host.local/api',
|
|
graphqlUrl: 'https://my-enterprise-host.local',
|
|
proxy: {
|
|
host: 'some-host',
|
|
port: 9000,
|
|
},
|
|
defaultBranch: 'dev',
|
|
})
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('outputs', () => {
|
|
it('sets appropriate outputs when GitHub release created', async () => {
|
|
restoreEnv = mockInputs({});
|
|
const fakeManifest = sandbox.createStubInstance(Manifest);
|
|
fakeManifest.createReleases.resolves([
|
|
{
|
|
id: 123456,
|
|
name: 'v1.2.3',
|
|
tagName: 'v1.2.3',
|
|
sha: 'abc123',
|
|
notes: 'Some release notes',
|
|
url: 'http://example2.com',
|
|
draft: false,
|
|
uploadUrl: 'http://example.com',
|
|
path: '.',
|
|
version: '1.2.3',
|
|
major: 1,
|
|
minor: 2,
|
|
patch: 3,
|
|
},
|
|
]);
|
|
fakeManifest.createPullRequests.resolves([]);
|
|
sandbox.stub(Manifest, 'fromManifest').resolves(fakeManifest);
|
|
await action.main();
|
|
sinon.assert.calledOnce(fakeManifest.createReleases);
|
|
sinon.assert.calledOnce(fakeManifest.createPullRequests);
|
|
|
|
assert.strictEqual(output.id, 123456);
|
|
assert.strictEqual(output.release_created, true);
|
|
assert.strictEqual(output.releases_created, true);
|
|
assert.strictEqual(output.upload_url, 'http://example.com');
|
|
assert.strictEqual(output.html_url, 'http://example2.com');
|
|
assert.strictEqual(output.tag_name, 'v1.2.3');
|
|
assert.strictEqual(output.major, 1);
|
|
assert.strictEqual(output.minor, 2);
|
|
assert.strictEqual(output.patch, 3);
|
|
assert.strictEqual(output.version, '1.2.3');
|
|
assert.strictEqual(output.sha, 'abc123');
|
|
assert.strictEqual(output.paths_released, '["."]');
|
|
});
|
|
|
|
it('sets appropriate outputs when release PR opened', async () => {
|
|
restoreEnv = mockInputs({});
|
|
const fakeManifest = sandbox.createStubInstance(Manifest);
|
|
fakeManifest.createReleases.resolves([]);
|
|
fakeManifest.createPullRequests.resolves([fixturePrs[0]]);
|
|
sandbox.stub(Manifest, 'fromManifest').resolves(fakeManifest);
|
|
await action.main();
|
|
sinon.assert.calledOnce(fakeManifest.createReleases);
|
|
sinon.assert.calledOnce(fakeManifest.createPullRequests);
|
|
|
|
const {pr, prs, prs_created} = output;
|
|
assert.strictEqual(prs_created, true);
|
|
assert.deepStrictEqual(pr, fixturePrs[0]);
|
|
assert.deepStrictEqual(prs, JSON.stringify([fixturePrs[0]]));
|
|
});
|
|
it('sets appropriate output if multiple releases are created', async () => {
|
|
restoreEnv = mockInputs({});
|
|
const fakeManifest = sandbox.createStubInstance(Manifest);
|
|
fakeManifest.createReleases.resolves([
|
|
{
|
|
id: 123456,
|
|
name: 'v1.0.0',
|
|
tagName: 'v1.0.0',
|
|
sha: 'abc123',
|
|
notes: 'Some release notes',
|
|
url: 'http://example2.com',
|
|
draft: false,
|
|
uploadUrl: 'http://example.com',
|
|
path: 'a',
|
|
version: '1.0.0',
|
|
major: 1,
|
|
minor: 0,
|
|
patch: 0,
|
|
},
|
|
{
|
|
id: 123,
|
|
name: 'v1.2.0',
|
|
tagName: 'v1.2.0',
|
|
sha: 'abc123',
|
|
notes: 'Some release notes',
|
|
url: 'http://example2.com',
|
|
draft: false,
|
|
uploadUrl: 'http://example.com',
|
|
path: 'b',
|
|
version: '1.2.0',
|
|
major: 1,
|
|
minor: 2,
|
|
patch: 0,
|
|
},
|
|
]);
|
|
fakeManifest.createPullRequests.resolves([]);
|
|
sandbox.stub(Manifest, 'fromManifest').resolves(fakeManifest);
|
|
await action.main();
|
|
sinon.assert.calledOnce(fakeManifest.createReleases);
|
|
|
|
assert.strictEqual(output['a--id'], 123456);
|
|
assert.strictEqual(output['a--release_created'], true);
|
|
assert.strictEqual(output['a--upload_url'], 'http://example.com');
|
|
assert.strictEqual(output['a--html_url'], 'http://example2.com');
|
|
assert.strictEqual(output['a--tag_name'], 'v1.0.0');
|
|
assert.strictEqual(output['a--major'], 1);
|
|
assert.strictEqual(output['a--minor'], 0);
|
|
assert.strictEqual(output['a--patch'], 0);
|
|
assert.strictEqual(output['a--version'], '1.0.0');
|
|
assert.strictEqual(output['a--sha'], 'abc123');
|
|
assert.strictEqual(output['a--path'], 'a');
|
|
|
|
assert.strictEqual(output['b--id'], 123);
|
|
assert.strictEqual(output['b--release_created'], true);
|
|
assert.strictEqual(output['b--upload_url'], 'http://example.com');
|
|
assert.strictEqual(output['b--html_url'], 'http://example2.com');
|
|
assert.strictEqual(output['b--tag_name'], 'v1.2.0');
|
|
assert.strictEqual(output['b--major'], 1);
|
|
assert.strictEqual(output['b--minor'], 2);
|
|
assert.strictEqual(output['b--patch'], 0);
|
|
assert.strictEqual(output['b--version'], '1.2.0');
|
|
assert.strictEqual(output['b--sha'], 'abc123');
|
|
assert.strictEqual(output['b--path'], 'b');
|
|
|
|
assert.strictEqual(output.paths_released, '["a","b"]');
|
|
assert.strictEqual(output.releases_created, true);
|
|
});
|
|
it('sets appropriate output if multiple release PR opened', async () => {
|
|
restoreEnv = mockInputs({});
|
|
const fakeManifest = sandbox.createStubInstance(Manifest);
|
|
fakeManifest.createReleases.resolves([]);
|
|
fakeManifest.createPullRequests.resolves(fixturePrs);
|
|
sandbox.stub(Manifest, 'fromManifest').resolves(fakeManifest);
|
|
await action.main();
|
|
sinon.assert.calledOnce(fakeManifest.createReleases);
|
|
sinon.assert.calledOnce(fakeManifest.createPullRequests);
|
|
|
|
const {pr, prs} = output;
|
|
assert.deepStrictEqual(pr, fixturePrs[0]);
|
|
assert.deepStrictEqual(prs, JSON.stringify(fixturePrs));
|
|
});
|
|
it('does not set outputs when no release created or PR returned', async () => {
|
|
restoreEnv = mockInputs({});
|
|
const fakeManifest = sandbox.createStubInstance(Manifest);
|
|
fakeManifest.createReleases.resolves([]);
|
|
fakeManifest.createPullRequests.resolves([]);
|
|
sandbox.stub(Manifest, 'fromManifest').resolves(fakeManifest);
|
|
await action.main();
|
|
sinon.assert.calledOnce(fakeManifest.createReleases);
|
|
sinon.assert.calledOnce(fakeManifest.createPullRequests);
|
|
|
|
assert.strictEqual(Object.hasOwnProperty.call(output, 'pr'), false);
|
|
assert.deepStrictEqual(output.paths_released, '[]');
|
|
assert.deepStrictEqual(output.prs_created, false);
|
|
assert.deepStrictEqual(output.releases_created, false);
|
|
});
|
|
});
|
|
});
|