blob: e13b8b9f372e57533ba087c7e72c5be1ce5f43dc [file] [log] [blame]
/**
* @license
* Copyright (C) 2016 The Android Open Source Project
*
* 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
*
* http://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 '../../../test/common-test-setup-karma';
import './gr-change-actions';
import {GerritNav} from '../../core/gr-navigation/gr-navigation';
import {getPluginLoader} from '../../shared/gr-js-api-interface/gr-plugin-loader';
import {
createAccountWithId,
createApproval,
createChange,
createChangeMessages,
createChangeViewChange,
createRevision,
createRevisions,
} from '../../../test/test-data-generators';
import {ChangeStatus, HttpMethod} from '../../../constants/constants';
import {
mockPromise,
query,
queryAll,
queryAndAssert,
stubReporting,
stubRestApi,
} from '../../../test/test-utils';
import {assertUIActionInfo, GrChangeActions} from './gr-change-actions';
import {
AccountId,
ActionInfo,
ActionNameToActionInfoMap,
BranchName,
ChangeId,
ChangeSubmissionId,
CommitId,
NumericChangeId,
PatchSetNum,
RepoName,
ReviewInput,
TopicName,
} from '../../../types/common';
import {ActionType} from '../../../api/change-actions';
import {tap} from '@polymer/iron-test-helpers/mock-interactions';
import {SinonFakeTimers} from 'sinon/pkg/sinon-esm';
import {IronAutogrowTextareaElement} from '@polymer/iron-autogrow-textarea';
import {GrButton} from '../../shared/gr-button/gr-button';
import {GrDialog} from '../../shared/gr-dialog/gr-dialog';
import {UIActionInfo} from '../../shared/gr-js-api-interface/gr-change-actions-js-api';
import {PolymerDeepPropertyChange} from '@polymer/polymer/interfaces';
import {appContext} from '../../../services/app-context';
const basicFixture = fixtureFromElement('gr-change-actions');
// TODO(dhruvsri): remove use of _populateRevertMessage as it's private
suite('gr-change-actions tests', () => {
let element: GrChangeActions;
suite('basic tests', () => {
setup(() => {
stubRestApi('getChangeRevisionActions').returns(
Promise.resolve({
cherrypick: {
method: HttpMethod.POST,
label: 'Cherry Pick',
title: 'Cherry pick change to a different branch',
enabled: true,
},
rebase: {
method: HttpMethod.POST,
label: 'Rebase',
title: 'Rebase onto tip of branch or parent change',
enabled: true,
},
submit: {
method: HttpMethod.POST,
label: 'Submit',
title: 'Submit patch set 2 into master',
enabled: true,
},
revert_submission: {
method: HttpMethod.POST,
label: 'Revert submission',
title: 'Revert this submission',
enabled: true,
},
})
);
stubRestApi('send').callsFake((method, url) => {
if (method !== 'POST') {
return Promise.reject(new Error('bad method'));
}
if (url === '/changes/test~42/revisions/2/submit') {
return Promise.resolve({
...new Response(),
ok: true,
text() {
return Promise.resolve(")]}'\n{}");
},
});
} else if (url === '/changes/test~42/revisions/2/rebase') {
return Promise.resolve({
...new Response(),
ok: true,
text() {
return Promise.resolve(")]}'\n{}");
},
});
}
return Promise.reject(new Error('bad url'));
});
sinon
.stub(getPluginLoader(), 'awaitPluginsLoaded')
.returns(Promise.resolve());
element = basicFixture.instantiate();
element.change = createChangeViewChange();
element.changeNum = 42 as NumericChangeId;
element.latestPatchNum = 2 as PatchSetNum;
element.actions = {
'/': {
method: HttpMethod.DELETE,
label: 'Delete Change',
title: 'Delete change X_X',
enabled: true,
},
};
element.account = {
_account_id: 123 as AccountId,
};
stubRestApi('getRepoBranches').returns(Promise.resolve([]));
return element.reload();
});
test('show-revision-actions event should fire', async () => {
const spy = sinon.spy(element, '_sendShowRevisionActions');
element.reload();
await flush();
assert.isTrue(spy.called);
});
test('primary and secondary actions split properly', () => {
// Submit should be the only primary action.
assert.equal(element._topLevelPrimaryActions!.length, 1);
assert.equal(element._topLevelPrimaryActions![0].label, 'Submit');
assert.equal(
element._topLevelSecondaryActions!.length,
element._topLevelActions!.length - 1
);
});
test('revert submission action is skipped', () => {
assert.equal(
element._allActionValues.filter(action => action.__key === 'submit')
.length,
1
);
assert.equal(
element._allActionValues.filter(
action => action.__key === 'revert_submission'
).length,
0
);
});
test('_shouldHideActions', () => {
assert.isTrue(element._shouldHideActions(undefined, true));
assert.isTrue(
element._shouldHideActions(
{base: [] as UIActionInfo[]} as PolymerDeepPropertyChange<
UIActionInfo[],
UIActionInfo[]
>,
false
)
);
assert.isFalse(
element._shouldHideActions(
{
base: [{__key: 'test'}] as UIActionInfo[],
} as PolymerDeepPropertyChange<UIActionInfo[], UIActionInfo[]>,
false
)
);
});
test('plugin revision actions', async () => {
const stub = stubRestApi('getChangeActionURL').returns(
Promise.resolve('the-url')
);
element.revisionActions = {
'plugin~action': {},
};
assert.isOk(element.revisionActions['plugin~action']);
await flush();
assert.isTrue(
stub.calledWith(
element.changeNum,
element.latestPatchNum,
'/plugin~action'
)
);
assert.equal(
(element.revisionActions['plugin~action'] as UIActionInfo)!.__url,
'the-url'
);
});
test('plugin change actions', async () => {
const stub = stubRestApi('getChangeActionURL').returns(
Promise.resolve('the-url')
);
element.actions = {
'plugin~action': {},
};
assert.isOk(element.actions['plugin~action']);
await flush();
assert.isTrue(
stub.calledWith(element.changeNum, undefined, '/plugin~action')
);
assert.equal(
(element.actions['plugin~action'] as UIActionInfo)!.__url,
'the-url'
);
});
test('not supported actions are filtered out', () => {
element.revisionActions = {followup: {}};
assert.equal(
element.querySelectorAll(
'section gr-button[data-action-type="revision"]'
).length,
0
);
});
test('getActionDetails', () => {
element.revisionActions = {
'plugin~action': {},
...element.revisionActions,
};
assert.isUndefined(element.getActionDetails('rubbish'));
assert.strictEqual(
element.revisionActions['plugin~action'],
element.getActionDetails('plugin~action')
);
assert.strictEqual(
element.revisionActions['rebase'],
element.getActionDetails('rebase')
);
});
test('hide revision action', async () => {
await flush();
let buttonEl: Element | undefined = queryAndAssert(
element,
'[data-action-key="submit"]'
);
assert.isOk(buttonEl);
element.setActionHidden(
element.ActionType.REVISION,
element.RevisionActions.SUBMIT,
true
);
assert.lengthOf(element._hiddenActions, 1);
element.setActionHidden(
element.ActionType.REVISION,
element.RevisionActions.SUBMIT,
true
);
assert.lengthOf(element._hiddenActions, 1);
await flush();
buttonEl = query(element, '[data-action-key="submit"]');
assert.isNotOk(buttonEl);
element.setActionHidden(
element.ActionType.REVISION,
element.RevisionActions.SUBMIT,
false
);
await flush();
buttonEl = queryAndAssert(element, '[data-action-key="submit"]');
assert.isFalse(buttonEl.hasAttribute('hidden'));
});
test('buttons exist', async () => {
element._loading = false;
await flush();
const buttonEls = queryAll(element, 'gr-button');
const menuItems = element.$.moreActions.items;
// Total button number is one greater than the number of total actions
// due to the existence of the overflow menu trigger.
assert.equal(
buttonEls!.length + menuItems!.length,
element._allActionValues.length + 1
);
assert.isFalse(element.hidden);
});
test('delete buttons have explicit labels', async () => {
await flush();
const deleteItems = element.$.moreActions.items!.filter(item =>
item.id!.startsWith('delete')
);
assert.equal(deleteItems.length, 1);
assert.equal(deleteItems[0].name, 'Delete change');
});
test('get revision object from change', () => {
const revObj = {
...createRevision(),
_number: 2 as PatchSetNum,
foo: 'bar',
};
const change = {
...createChangeViewChange(),
revisions: {
rev1: {...createRevision(), _number: 1 as PatchSetNum},
rev2: revObj,
},
};
assert.deepEqual(element._getRevision(change, 2 as PatchSetNum), revObj);
});
test('_actionComparator sort order', () => {
const actions = [
{label: '123', __type: ActionType.CHANGE, __key: 'review'},
{label: 'abc-ro', __type: ActionType.REVISION, __key: 'random'},
{label: 'abc', __type: ActionType.CHANGE, __key: 'random'},
{label: 'def', __type: ActionType.CHANGE, __key: 'random'},
{
label: 'def-p',
__type: ActionType.CHANGE,
__primary: true,
__key: 'random',
},
];
const result = actions.slice();
result.reverse();
result.sort(element._actionComparator.bind(element));
assert.deepEqual(result, actions);
});
test('submit change', async () => {
const showSpy = sinon.spy(element, '_showActionDialog');
stubRestApi('getFromProjectLookup').returns(
Promise.resolve('test' as RepoName)
);
sinon.stub(element.$.overlay, 'open').returns(Promise.resolve());
element.change = {
...createChangeViewChange(),
revisions: {
rev1: {...createRevision(), _number: 1 as PatchSetNum},
rev2: {...createRevision(), _number: 2 as PatchSetNum},
},
};
element.latestPatchNum = 2 as PatchSetNum;
const submitButton = queryAndAssert(
element,
'gr-button[data-action-key="submit"]'
);
tap(submitButton);
await flush();
assert.isTrue(showSpy.calledWith(element.$.confirmSubmitDialog));
});
test('submit change, tap on icon', async () => {
const submitted = mockPromise();
sinon
.stub(element.$.confirmSubmitDialog, 'resetFocus')
.callsFake(() => submitted.resolve());
stubRestApi('getFromProjectLookup').returns(
Promise.resolve('test' as RepoName)
);
sinon.stub(element.$.overlay, 'open').returns(Promise.resolve());
element.change = {
...createChangeViewChange(),
revisions: {
rev1: {...createRevision(), _number: 1 as PatchSetNum},
rev2: {...createRevision(), _number: 2 as PatchSetNum},
},
};
element.latestPatchNum = 2 as PatchSetNum;
const submitIcon = queryAndAssert(
element,
'gr-button[data-action-key="submit"] iron-icon'
);
tap(submitIcon);
await submitted;
});
test('_handleSubmitConfirm', () => {
const fireStub = sinon.stub(element, '_fireAction');
sinon.stub(element, '_canSubmitChange').returns(true);
element._handleSubmitConfirm();
assert.isTrue(fireStub.calledOnce);
assert.deepEqual(fireStub.lastCall.args, [
'/submit',
assertUIActionInfo(element.revisionActions.submit),
true,
]);
});
test('_handleSubmitConfirm when not able to submit', () => {
const fireStub = sinon.stub(element, '_fireAction');
sinon.stub(element, '_canSubmitChange').returns(false);
element._handleSubmitConfirm();
assert.isFalse(fireStub.called);
});
test('submit change with plugin hook', async () => {
sinon.stub(element, '_canSubmitChange').callsFake(() => false);
const fireActionStub = sinon.stub(element, '_fireAction');
await flush();
const submitButton = queryAndAssert(
element,
'gr-button[data-action-key="submit"]'
);
tap(submitButton);
assert.equal(fireActionStub.callCount, 0);
});
test('chain state', () => {
assert.equal(element._hasKnownChainState, false);
element.hasParent = true;
assert.equal(element._hasKnownChainState, true);
element.hasParent = false;
});
test('_calculateDisabled', () => {
let hasKnownChainState = false;
const action = {
__key: 'rebase',
enabled: true,
__type: ActionType.CHANGE,
label: 'l',
};
assert.equal(
element._calculateDisabled(action, hasKnownChainState),
true
);
action.__key = 'delete';
assert.equal(
element._calculateDisabled(action, hasKnownChainState),
false
);
action.__key = 'rebase';
hasKnownChainState = true;
assert.equal(
element._calculateDisabled(action, hasKnownChainState),
false
);
action.enabled = false;
assert.equal(
element._calculateDisabled(action, hasKnownChainState),
false
);
});
test('rebase change', async () => {
const fireActionStub = sinon.stub(element, '_fireAction');
const fetchChangesStub = sinon
.stub(element.$.confirmRebase, 'fetchRecentChanges')
.returns(Promise.resolve([]));
element._hasKnownChainState = true;
await flush();
const rebaseButton = queryAndAssert(
element,
'gr-button[data-action-key="rebase"]'
);
tap(rebaseButton);
const rebaseAction = {
__key: 'rebase',
__type: 'revision',
__primary: false,
enabled: true,
label: 'Rebase',
method: HttpMethod.POST,
title: 'Rebase onto tip of branch or parent change',
};
assert.isTrue(fetchChangesStub.called);
element._handleRebaseConfirm(
new CustomEvent('', {detail: {base: '1234'}})
);
assert.deepEqual(fireActionStub.lastCall.args, [
'/rebase',
assertUIActionInfo(rebaseAction),
true,
{base: '1234'},
]);
});
test('rebase change fires reload event', async () => {
const eventStub = sinon.stub(element, 'dispatchEvent');
element._handleResponse(
{__key: 'rebase', __type: ActionType.CHANGE, label: 'l'},
new Response()
);
await flush();
assert.isTrue(eventStub.called);
assert.equal(eventStub.lastCall.args[0].type, 'reload');
});
test("rebase dialog gets recent changes each time it's opened", async () => {
const fetchChangesStub = sinon
.stub(element.$.confirmRebase, 'fetchRecentChanges')
.returns(Promise.resolve([]));
element._hasKnownChainState = true;
const rebaseButton = queryAndAssert(
element,
'gr-button[data-action-key="rebase"]'
);
tap(rebaseButton);
assert.isTrue(fetchChangesStub.calledOnce);
await flush();
element.$.confirmRebase.dispatchEvent(
new CustomEvent('cancel', {
composed: true,
bubbles: true,
})
);
tap(rebaseButton);
assert.isTrue(fetchChangesStub.calledTwice);
});
test('two dialogs are not shown at the same time', async () => {
element._hasKnownChainState = true;
await flush();
const rebaseButton = queryAndAssert(
element,
'gr-button[data-action-key="rebase"]'
);
tap(rebaseButton);
await flush();
assert.isFalse(element.$.confirmRebase.hidden);
stubRestApi('getChanges').returns(Promise.resolve([]));
element._handleCherrypickTap();
await flush();
assert.isTrue(element.$.confirmRebase.hidden);
assert.isFalse(element.$.confirmCherrypick.hidden);
});
test('fullscreen-overlay-opened hides content', () => {
const spy = sinon.spy(element, '_handleHideBackgroundContent');
element.$.overlay.dispatchEvent(
new CustomEvent('fullscreen-overlay-opened', {
composed: true,
bubbles: true,
})
);
assert.isTrue(spy.called);
assert.isTrue(element.$.mainContent.classList.contains('overlayOpen'));
});
test('fullscreen-overlay-closed shows content', () => {
const spy = sinon.spy(element, '_handleShowBackgroundContent');
element.$.overlay.dispatchEvent(
new CustomEvent('fullscreen-overlay-closed', {
composed: true,
bubbles: true,
})
);
assert.isTrue(spy.called);
assert.isFalse(element.$.mainContent.classList.contains('overlayOpen'));
});
test('_setReviewOnRevert', () => {
const review = {labels: {Foo: 1, 'Bar-Baz': -2}};
const changeId = 1234 as NumericChangeId;
sinon
.stub(appContext.jsApiService, 'getReviewPostRevert')
.returns(review);
const saveStub = stubRestApi('saveChangeReview').returns(
Promise.resolve(new Response())
);
const setReviewOnRevert = element._setReviewOnRevert(changeId) as Promise<
undefined | Response
>;
return setReviewOnRevert.then((_res: Response | undefined) => {
assert.isTrue(saveStub.calledOnce);
assert.equal(saveStub.lastCall.args[0], changeId);
assert.deepEqual(saveStub.lastCall.args[2], review);
});
});
suite('change edits', () => {
test('disableEdit', async () => {
element.set('editMode', false);
element.set('editPatchsetLoaded', false);
element.change = {
...createChangeViewChange(),
status: ChangeStatus.NEW,
};
element.set('disableEdit', true);
await flush();
assert.isNotOk(
query(element, 'gr-button[data-action-key="publishEdit"]')
);
assert.isNotOk(
query(element, 'gr-button[data-action-key="rebaseEdit"]')
);
assert.isNotOk(
query(element, 'gr-button[data-action-key="deleteEdit"]')
);
assert.isNotOk(query(element, 'gr-button[data-action-key="edit"]'));
assert.isNotOk(query(element, 'gr-button[data-action-key="stopEdit"]'));
});
test('shows confirm dialog for delete edit', async () => {
element.set('editMode', true);
element.set('editPatchsetLoaded', true);
const fireActionStub = sinon.stub(element, '_fireAction');
element._handleDeleteEditTap();
assert.isFalse(element.$.confirmDeleteEditDialog.hidden);
tap(
queryAndAssert(
queryAndAssert(element, '#confirmDeleteEditDialog'),
'gr-button[primary]'
)
);
await flush();
assert.equal(fireActionStub.lastCall.args[0], '/edit');
});
test('edit patchset is loaded, needs rebase', async () => {
element.set('editMode', true);
element.set('editPatchsetLoaded', true);
element.change = {
...createChangeViewChange(),
status: ChangeStatus.NEW,
};
element.editBasedOnCurrentPatchSet = false;
await flush();
assert.isNotOk(
query(element, 'gr-button[data-action-key="publishEdit"]')
);
assert.isOk(query(element, 'gr-button[data-action-key="rebaseEdit"]'));
assert.isOk(query(element, 'gr-button[data-action-key="deleteEdit"]'));
assert.isNotOk(query(element, 'gr-button[data-action-key="edit"]'));
assert.isNotOk(query(element, 'gr-button[data-action-key="stopEdit"]'));
});
test('edit patchset is loaded, does not need rebase', async () => {
element.set('editMode', true);
element.set('editPatchsetLoaded', true);
element.change = {
...createChangeViewChange(),
status: ChangeStatus.NEW,
};
element.editBasedOnCurrentPatchSet = true;
await flush();
assert.isOk(query(element, 'gr-button[data-action-key="publishEdit"]'));
assert.isNotOk(
query(element, 'gr-button[data-action-key="rebaseEdit"]')
);
assert.isOk(query(element, 'gr-button[data-action-key="deleteEdit"]'));
assert.isNotOk(query(element, 'gr-button[data-action-key="edit"]'));
assert.isNotOk(query(element, 'gr-button[data-action-key="stopEdit"]'));
});
test('edit mode is loaded, no edit patchset', async () => {
element.set('editMode', true);
element.set('editPatchsetLoaded', false);
element.change = {
...createChangeViewChange(),
status: ChangeStatus.NEW,
};
await flush();
assert.isNotOk(
query(element, 'gr-button[data-action-key="publishEdit"]')
);
assert.isNotOk(
query(element, 'gr-button[data-action-key="rebaseEdit"]')
);
assert.isNotOk(
query(element, 'gr-button[data-action-key="deleteEdit"]')
);
assert.isNotOk(query(element, 'gr-button[data-action-key="edit"]'));
assert.isOk(query(element, 'gr-button[data-action-key="stopEdit"]'));
});
test('normal patch set', async () => {
element.set('editMode', false);
element.set('editPatchsetLoaded', false);
element.change = {
...createChangeViewChange(),
status: ChangeStatus.NEW,
};
await flush();
assert.isNotOk(
query(element, 'gr-button[data-action-key="publishEdit"]')
);
assert.isNotOk(
query(element, 'gr-button[data-action-key="rebaseEdit"]')
);
assert.isNotOk(
query(element, 'gr-button[data-action-key="deleteEdit"]')
);
assert.isOk(query(element, 'gr-button[data-action-key="edit"]'));
assert.isNotOk(query(element, 'gr-button[data-action-key="stopEdit"]'));
});
test('edit action', async () => {
const editTapped = mockPromise();
element.addEventListener('edit-tap', () => {
editTapped.resolve();
});
element.set('editMode', true);
element.change = {
...createChangeViewChange(),
status: ChangeStatus.NEW,
};
await flush();
assert.isNotOk(query(element, 'gr-button[data-action-key="edit"]'));
assert.isOk(query(element, 'gr-button[data-action-key="stopEdit"]'));
element.change = {
...createChangeViewChange(),
status: ChangeStatus.MERGED,
};
await flush();
assert.isNotOk(query(element, 'gr-button[data-action-key="edit"]'));
element.change = {
...createChangeViewChange(),
status: ChangeStatus.NEW,
};
element.set('editMode', false);
await flush();
const editButton = queryAndAssert(
element,
'gr-button[data-action-key="edit"]'
);
tap(editButton);
await editTapped;
});
});
suite('cherry-pick', () => {
let fireActionStub: sinon.SinonStub;
setup(() => {
fireActionStub = sinon.stub(element, '_fireAction');
sinon.stub(window, 'alert');
});
test('works', () => {
element._handleCherrypickTap();
const action = {
__key: 'cherrypick',
__type: 'revision',
__primary: false,
enabled: true,
label: 'Cherry pick',
method: HttpMethod.POST,
title: 'Cherry pick change to a different branch',
};
element._handleCherrypickConfirm();
assert.equal(fireActionStub.callCount, 0);
element.$.confirmCherrypick.branch = 'master' as BranchName;
element._handleCherrypickConfirm();
assert.equal(fireActionStub.callCount, 0); // Still needs a message.
// Add attributes that are used to determine the message.
element.$.confirmCherrypick.commitMessage = 'foo message';
element.$.confirmCherrypick.changeStatus = ChangeStatus.NEW;
element.$.confirmCherrypick.commitNum = '123' as CommitId;
element._handleCherrypickConfirm();
const autogrowEl = queryAndAssert(
element.$.confirmCherrypick,
'#messageInput'
) as IronAutogrowTextareaElement;
assert.equal(autogrowEl.value, 'foo message');
assert.deepEqual(fireActionStub.lastCall.args, [
'/cherrypick',
action,
true,
{
destination: 'master',
base: null,
message: 'foo message',
allow_conflicts: false,
},
]);
});
test('cherry pick even with conflicts', () => {
element._handleCherrypickTap();
const action = {
__key: 'cherrypick',
__type: 'revision',
__primary: false,
enabled: true,
label: 'Cherry pick',
method: HttpMethod.POST,
title: 'Cherry pick change to a different branch',
};
element.$.confirmCherrypick.branch = 'master' as BranchName;
// Add attributes that are used to determine the message.
element.$.confirmCherrypick.commitMessage = 'foo message';
element.$.confirmCherrypick.changeStatus = ChangeStatus.NEW;
element.$.confirmCherrypick.commitNum = '123' as CommitId;
element._handleCherrypickConflictConfirm();
assert.deepEqual(fireActionStub.lastCall.args, [
'/cherrypick',
action,
true,
{
destination: 'master',
base: null,
message: 'foo message',
allow_conflicts: true,
},
]);
});
test('branch name cleared when re-open cherrypick', () => {
const emptyBranchName = '';
element.$.confirmCherrypick.branch = 'master' as BranchName;
element._handleCherrypickTap();
assert.equal(element.$.confirmCherrypick.branch, emptyBranchName);
});
suite('cherry pick topics', () => {
const changes = [
{
...createChangeViewChange(),
change_id: '12345678901234' as ChangeId,
topic: 'T' as TopicName,
subject: 'random',
project: 'A' as RepoName,
status: ChangeStatus.MERGED,
},
{
...createChangeViewChange(),
change_id: '23456' as ChangeId,
topic: 'T' as TopicName,
subject: 'a'.repeat(100),
project: 'B' as RepoName,
status: ChangeStatus.NEW,
},
];
setup(async () => {
stubRestApi('getChanges').returns(Promise.resolve(changes));
element._handleCherrypickTap();
await flush();
const radioButtons = queryAll(
element.$.confirmCherrypick,
"input[name='cherryPickOptions']"
);
assert.equal(radioButtons.length, 2);
tap(radioButtons[1]);
await flush();
});
test('cherry pick topic dialog is rendered', async () => {
const dialog = element.$.confirmCherrypick;
await flush();
const changesTable = queryAndAssert(dialog, 'table');
const headers = Array.from(changesTable.querySelectorAll('th'));
const expectedHeadings = [
'',
'Change',
'Status',
'Subject',
'Project',
'Progress',
'',
];
const headings = headers.map(header => header.innerText);
assert.equal(headings.length, expectedHeadings.length);
for (let i = 0; i < headings.length; i++) {
assert.equal(headings[i].trim(), expectedHeadings[i]);
}
const changeRows = queryAll(changesTable, 'tbody > tr');
const change = Array.from(changeRows[0].querySelectorAll('td')).map(
e => e.innerText
);
const expectedChange = [
'',
'1234567890',
'MERGED',
'random',
'A',
'NOT STARTED',
'',
];
for (let i = 0; i < change.length; i++) {
assert.equal(change[i].trim(), expectedChange[i]);
}
});
test('changes with duplicate project show an error', async () => {
const dialog = element.$.confirmCherrypick;
const error = queryAndAssert(
dialog,
'.error-message'
) as HTMLSpanElement;
assert.equal(error.innerText, '');
dialog.updateChanges([
{
...createChangeViewChange(),
change_id: '12345678901234' as ChangeId,
topic: 'T' as TopicName,
subject: 'random',
project: 'A' as RepoName,
},
{
...createChangeViewChange(),
change_id: '23456' as ChangeId,
topic: 'T' as TopicName,
subject: 'a'.repeat(100),
project: 'A' as RepoName,
},
]);
await flush();
assert.equal(
error.innerText,
'Two changes cannot be of the same' + ' project'
);
});
});
});
suite('move change', () => {
let fireActionStub: sinon.SinonStub;
setup(() => {
fireActionStub = sinon.stub(element, '_fireAction');
sinon.stub(window, 'alert');
element.actions = {
move: {
method: HttpMethod.POST,
label: 'Move',
title: 'Move the change',
enabled: true,
},
};
});
test('works', () => {
element._handleMoveTap();
element._handleMoveConfirm();
assert.equal(fireActionStub.callCount, 0);
element.$.confirmMove.branch = 'master' as BranchName;
element._handleMoveConfirm();
assert.equal(fireActionStub.callCount, 1);
});
test('branch name cleared when re-open move', () => {
const emptyBranchName = '';
element.$.confirmMove.branch = 'master' as BranchName;
element._handleMoveTap();
assert.equal(element.$.confirmMove.branch, emptyBranchName);
});
});
test('custom actions', async () => {
// Add a button with the same key as a server-based one to ensure
// collisions are taken care of.
const key = element.addActionButton(element.ActionType.REVISION, 'Bork!');
const keyTapped = mockPromise();
element.addEventListener(key + '-tap', async e => {
assert.equal(
(e as CustomEvent).detail.node.getAttribute('data-action-key'),
key
);
element.removeActionButton(key);
await flush();
assert.notOk(query(element, '[data-action-key="' + key + '"]'));
keyTapped.resolve();
});
await flush();
tap(queryAndAssert(element, '[data-action-key="' + key + '"]'));
await keyTapped;
});
test('_setLoadingOnButtonWithKey top-level', () => {
const key = 'rebase';
const type = 'revision';
const cleanup = element._setLoadingOnButtonWithKey(type, key);
assert.equal(element._actionLoadingMessage, 'Rebasing...');
const button = queryAndAssert(
element,
'[data-action-key="' + key + '"]'
) as GrButton;
assert.isTrue(button.hasAttribute('loading'));
assert.isTrue(button.disabled);
assert.isOk(cleanup);
assert.isFunction(cleanup);
cleanup();
assert.isFalse(button.hasAttribute('loading'));
assert.isFalse(button.disabled);
assert.isNotOk(element._actionLoadingMessage);
});
test('_setLoadingOnButtonWithKey overflow menu', () => {
const key = 'cherrypick';
const type = 'revision';
const cleanup = element._setLoadingOnButtonWithKey(type, key);
assert.equal(element._actionLoadingMessage, 'Cherry-picking...');
assert.include(element._disabledMenuActions, 'cherrypick');
assert.isFunction(cleanup);
cleanup();
assert.notOk(element._actionLoadingMessage);
assert.notInclude(element._disabledMenuActions, 'cherrypick');
});
suite('abandon change', () => {
let alertStub: sinon.SinonStub;
let fireActionStub: sinon.SinonStub;
setup(() => {
fireActionStub = sinon.stub(element, '_fireAction');
alertStub = sinon.stub(window, 'alert');
element.actions = {
abandon: {
method: HttpMethod.POST,
label: 'Abandon',
title: 'Abandon the change',
enabled: true,
},
};
return element.reload();
});
test('abandon change with message', async () => {
const newAbandonMsg = 'Test Abandon Message';
element.$.confirmAbandonDialog.message = newAbandonMsg;
await flush();
const abandonButton = queryAndAssert(
element,
'gr-button[data-action-key="abandon"]'
);
tap(abandonButton);
assert.equal(element.$.confirmAbandonDialog.message, newAbandonMsg);
});
test('abandon change with no message', async () => {
await flush();
const abandonButton = queryAndAssert(
element,
'gr-button[data-action-key="abandon"]'
);
tap(abandonButton);
assert.isUndefined(element.$.confirmAbandonDialog.message);
});
test('works', () => {
element.$.confirmAbandonDialog.message = 'original message';
const restoreButton = queryAndAssert(
element,
'gr-button[data-action-key="abandon"]'
);
tap(restoreButton);
element.$.confirmAbandonDialog.message = 'foo message';
element._handleAbandonDialogConfirm();
assert.notOk(alertStub.called);
const action = {
__key: 'abandon',
__type: 'change',
__primary: false,
enabled: true,
label: 'Abandon',
method: HttpMethod.POST,
title: 'Abandon the change',
};
assert.deepEqual(fireActionStub.lastCall.args, [
'/abandon',
action,
false,
{
message: 'foo message',
},
]);
});
});
suite('revert change', () => {
let fireActionStub: sinon.SinonStub;
setup(() => {
fireActionStub = sinon.stub(element, '_fireAction');
element.commitMessage = 'random commit message';
element.change!.current_revision = 'abcdef' as CommitId;
element.actions = {
revert: {
method: HttpMethod.POST,
label: 'Revert',
title: 'Revert the change',
enabled: true,
},
};
return element.reload();
});
test('revert change with plugin hook', async () => {
const newRevertMsg = 'Modified revert msg';
sinon
.stub(element.$.confirmRevertDialog, '_modifyRevertMsg')
.callsFake(() => newRevertMsg);
element.change = {
...createChangeViewChange(),
current_revision: 'abc1234' as CommitId,
};
stubRestApi('getChanges').returns(
Promise.resolve([
{
...createChange(),
change_id: '12345678901234' as ChangeId,
topic: 'T' as TopicName,
subject: 'random',
},
{
...createChange(),
change_id: '23456' as ChangeId,
topic: 'T' as TopicName,
subject: 'a'.repeat(100),
},
])
);
sinon
.stub(
element.$.confirmRevertDialog,
'_populateRevertSubmissionMessage'
)
.callsFake(() => 'original msg');
await flush();
const revertButton = queryAndAssert(
element,
'gr-button[data-action-key="revert"]'
);
tap(revertButton);
await flush();
assert.equal(element.$.confirmRevertDialog._message, newRevertMsg);
});
suite('revert change submitted together', () => {
let getChangesStub: sinon.SinonStub;
setup(() => {
element.change = {
...createChangeViewChange(),
submission_id: '199 0' as ChangeSubmissionId,
current_revision: '2000' as CommitId,
};
getChangesStub = stubRestApi('getChanges').returns(
Promise.resolve([
{
...createChange(),
change_id: '12345678901234' as ChangeId,
topic: 'T' as TopicName,
subject: 'random',
},
{
...createChange(),
change_id: '23456' as ChangeId,
topic: 'T' as TopicName,
subject: 'a'.repeat(100),
},
])
);
});
test('confirm revert dialog shows both options', async () => {
const revertButton = queryAndAssert(
element,
'gr-button[data-action-key="revert"]'
);
tap(revertButton);
await flush();
assert.equal(getChangesStub.args[0][1], 'submissionid: "199 0"');
const confirmRevertDialog = element.$.confirmRevertDialog;
const revertSingleChangeLabel = queryAndAssert(
confirmRevertDialog,
'.revertSingleChange'
) as HTMLLabelElement;
const revertSubmissionLabel = queryAndAssert(
confirmRevertDialog,
'.revertSubmission'
) as HTMLLabelElement;
assert(
revertSingleChangeLabel.innerText.trim() === 'Revert single change'
);
assert(
revertSubmissionLabel.innerText.trim() ===
'Revert entire submission (2 Changes)'
);
let expectedMsg =
'Revert submission 199 0' +
'\n\n' +
'Reason for revert: <INSERT REASONING HERE>' +
'\n' +
'Reverted Changes:' +
'\n' +
'1234567890:random' +
'\n' +
'23456:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa...' +
'\n';
assert.equal(confirmRevertDialog._message, expectedMsg);
const radioInputs = queryAll(
confirmRevertDialog,
'input[name="revertOptions"]'
);
tap(radioInputs[0]);
await flush();
expectedMsg =
'Revert "random commit message"\n\nThis reverts ' +
'commit 2000.\n\nReason' +
' for revert: <INSERT REASONING HERE>\n';
assert.equal(confirmRevertDialog._message, expectedMsg);
});
test('submit fails if message is not edited', async () => {
const revertButton = queryAndAssert(
element,
'gr-button[data-action-key="revert"]'
);
const confirmRevertDialog = element.$.confirmRevertDialog;
tap(revertButton);
const fireStub = sinon.stub(confirmRevertDialog, 'dispatchEvent');
await flush();
const confirmButton = queryAndAssert(
queryAndAssert(element.$.confirmRevertDialog, 'gr-dialog'),
'#confirm'
);
tap(confirmButton);
await flush();
assert.isTrue(confirmRevertDialog._showErrorMessage);
assert.isFalse(fireStub.called);
});
test('message modification is retained on switching', async () => {
const revertButton = queryAndAssert(
element,
'gr-button[data-action-key="revert"]'
);
const confirmRevertDialog = element.$.confirmRevertDialog;
tap(revertButton);
await flush();
const radioInputs = queryAll(
confirmRevertDialog,
'input[name="revertOptions"]'
);
const revertSubmissionMsg =
'Revert submission 199 0' +
'\n\n' +
'Reason for revert: <INSERT REASONING HERE>' +
'\n' +
'Reverted Changes:' +
'\n' +
'1234567890:random' +
'\n' +
'23456:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa...' +
'\n';
const singleChangeMsg =
'Revert "random commit message"\n\nThis reverts ' +
'commit 2000.\n\nReason' +
' for revert: <INSERT REASONING HERE>\n';
assert.equal(confirmRevertDialog._message, revertSubmissionMsg);
const newRevertMsg = revertSubmissionMsg + 'random';
const newSingleChangeMsg = singleChangeMsg + 'random';
confirmRevertDialog._message = newRevertMsg;
tap(radioInputs[0]);
await flush();
assert.equal(confirmRevertDialog._message, singleChangeMsg);
confirmRevertDialog._message = newSingleChangeMsg;
tap(radioInputs[1]);
await flush();
assert.equal(confirmRevertDialog._message, newRevertMsg);
tap(radioInputs[0]);
await flush();
assert.equal(confirmRevertDialog._message, newSingleChangeMsg);
});
});
suite('revert single change', () => {
setup(() => {
element.change = {
...createChangeViewChange(),
submission_id: '199' as ChangeSubmissionId,
current_revision: '2000' as CommitId,
};
stubRestApi('getChanges').returns(
Promise.resolve([
{
...createChange(),
change_id: '12345678901234' as ChangeId,
topic: 'T' as TopicName,
subject: 'random',
},
])
);
});
test('submit fails if message is not edited', async () => {
const revertButton = queryAndAssert(
element,
'gr-button[data-action-key="revert"]'
);
const confirmRevertDialog = element.$.confirmRevertDialog;
tap(revertButton);
const fireStub = sinon.stub(confirmRevertDialog, 'dispatchEvent');
await flush();
const confirmButton = queryAndAssert(
queryAndAssert(element.$.confirmRevertDialog, 'gr-dialog'),
'#confirm'
);
tap(confirmButton);
await flush();
assert.isTrue(confirmRevertDialog._showErrorMessage);
assert.isFalse(fireStub.called);
});
test('confirm revert dialog shows no radio button', async () => {
const revertButton = queryAndAssert(
element,
'gr-button[data-action-key="revert"]'
);
tap(revertButton);
await flush();
const confirmRevertDialog = element.$.confirmRevertDialog;
const radioInputs = queryAll(
confirmRevertDialog,
'input[name="revertOptions"]'
);
assert.equal(radioInputs.length, 0);
const msg =
'Revert "random commit message"\n\n' +
'This reverts commit 2000.\n\nReason ' +
'for revert: <INSERT REASONING HERE>\n';
assert.equal(confirmRevertDialog._message, msg);
const editedMsg = msg + 'hello';
confirmRevertDialog._message += 'hello';
const confirmButton = queryAndAssert(
queryAndAssert(element.$.confirmRevertDialog, 'gr-dialog'),
'#confirm'
);
tap(confirmButton);
await flush();
assert.equal(fireActionStub.getCall(0).args[0], '/revert');
assert.equal(fireActionStub.getCall(0).args[1].__key, 'revert');
assert.equal(fireActionStub.getCall(0).args[3].message, editedMsg);
});
});
});
suite('mark change private', () => {
setup(() => {
const privateAction = {
__key: 'private',
__type: 'change',
__primary: false,
method: HttpMethod.POST,
label: 'Mark private',
title: 'Working...',
enabled: true,
};
element.actions = {
private: privateAction,
};
element.change!.is_private = false;
element.changeNum = 2 as NumericChangeId;
element.latestPatchNum = 2 as PatchSetNum;
return element.reload();
});
test(
'make sure the mark private change button is not outside of the ' +
'overflow menu',
async () => {
await flush();
assert.isNotOk(query(element, '[data-action-key="private"]'));
}
);
test('private change', async () => {
await flush();
assert.isOk(
query(element.$.moreActions, 'span[data-id="private-change"]')
);
element.setActionOverflow(ActionType.CHANGE, 'private', false);
await flush();
assert.isOk(query(element, '[data-action-key="private"]'));
assert.isNotOk(
query(element.$.moreActions, 'span[data-id="private-change"]')
);
});
});
suite('unmark private change', () => {
setup(() => {
const unmarkPrivateAction = {
__key: 'private.delete',
__type: 'change',
__primary: false,
method: HttpMethod.POST,
label: 'Unmark private',
title: 'Working...',
enabled: true,
};
element.actions = {
'private.delete': unmarkPrivateAction,
};
element.change!.is_private = true;
element.changeNum = 2 as NumericChangeId;
element.latestPatchNum = 2 as PatchSetNum;
return element.reload();
});
test(
'make sure the unmark private change button is not outside of the ' +
'overflow menu',
async () => {
await flush();
assert.isNotOk(query(element, '[data-action-key="private.delete"]'));
}
);
test('unmark the private change', async () => {
await flush();
assert.isOk(
query(element.$.moreActions, 'span[data-id="private.delete-change"]')
);
element.setActionOverflow(ActionType.CHANGE, 'private.delete', false);
await flush();
assert.isOk(query(element, '[data-action-key="private.delete"]'));
assert.isNotOk(
query(element.$.moreActions, 'span[data-id="private.delete-change"]')
);
});
});
suite('delete change', () => {
let fireActionStub: sinon.SinonStub;
let deleteAction: ActionInfo;
setup(() => {
fireActionStub = sinon.stub(element, '_fireAction');
element.change = {
...createChangeViewChange(),
current_revision: 'abc1234' as CommitId,
};
deleteAction = {
method: HttpMethod.DELETE,
label: 'Delete Change',
title: 'Delete change X_X',
enabled: true,
};
element.actions = {
'/': deleteAction,
};
});
test('does not delete on action', () => {
element._handleDeleteTap();
assert.isFalse(fireActionStub.called);
});
test('shows confirm dialog', async () => {
element._handleDeleteTap();
assert.isFalse(
(queryAndAssert(element, '#confirmDeleteDialog') as GrDialog).hidden
);
tap(
queryAndAssert(
queryAndAssert(element, '#confirmDeleteDialog'),
'gr-button[primary]'
)
);
await flush();
assert.isTrue(fireActionStub.calledWith('/', deleteAction, false));
});
test('hides delete confirm on cancel', async () => {
element._handleDeleteTap();
tap(
queryAndAssert(
queryAndAssert(element, '#confirmDeleteDialog'),
'gr-button:not([primary])'
)
);
await flush();
assert.isTrue(
(queryAndAssert(element, '#confirmDeleteDialog') as GrDialog).hidden
);
assert.isFalse(fireActionStub.called);
});
});
suite('ignore change', () => {
setup(async () => {
sinon.stub(element, '_fireAction');
const IgnoreAction = {
__key: 'ignore',
__type: 'change',
__primary: false,
method: HttpMethod.PUT,
label: 'Ignore',
title: 'Working...',
enabled: true,
};
element.actions = {
ignore: IgnoreAction,
};
element.changeNum = 2 as NumericChangeId;
element.latestPatchNum = 2 as PatchSetNum;
await element.reload();
await flush();
});
test('make sure the ignore button is not outside of the overflow menu', () => {
assert.isNotOk(query(element, '[data-action-key="ignore"]'));
});
test('ignoring change', async () => {
queryAndAssert(element.$.moreActions, 'span[data-id="ignore-change"]');
element.setActionOverflow(ActionType.CHANGE, 'ignore', false);
await flush();
queryAndAssert(element, '[data-action-key="ignore"]');
assert.isNotOk(
query(element.$.moreActions, 'span[data-id="ignore-change"]')
);
});
});
suite('unignore change', () => {
setup(async () => {
sinon.stub(element, '_fireAction');
const UnignoreAction = {
__key: 'unignore',
__type: 'change',
__primary: false,
method: HttpMethod.PUT,
label: 'Unignore',
title: 'Working...',
enabled: true,
};
element.actions = {
unignore: UnignoreAction,
};
element.changeNum = 2 as NumericChangeId;
element.latestPatchNum = 2 as PatchSetNum;
await element.reload();
await flush();
});
test('unignore button is not outside of the overflow menu', () => {
assert.isNotOk(query(element, '[data-action-key="unignore"]'));
});
test('unignoring change', async () => {
assert.isOk(
query(element.$.moreActions, 'span[data-id="unignore-change"]')
);
element.setActionOverflow(ActionType.CHANGE, 'unignore', false);
await flush();
assert.isOk(query(element, '[data-action-key="unignore"]'));
assert.isNotOk(
query(element.$.moreActions, 'span[data-id="unignore-change"]')
);
});
});
suite('quick approve', () => {
setup(async () => {
element.change = {
...createChangeViewChange(),
current_revision: 'abc1234' as CommitId,
labels: {
foo: {
values: {
'-1': '',
' 0': '',
'+1': '',
},
},
},
permitted_labels: {
foo: ['-1', ' 0', '+1'],
},
};
await flush();
});
test('added when can approve', () => {
const approveButton = queryAndAssert(
element,
"gr-button[data-action-key='review']"
);
assert.isNotNull(approveButton);
});
test('hide quick approve', async () => {
const approveButton = query(
element,
"gr-button[data-action-key='review']"
);
assert.isNotNull(approveButton);
assert.isFalse(element._hideQuickApproveAction);
// Assert approve button gets removed from list of buttons.
element.hideQuickApproveAction();
await flush();
const approveButtonUpdated = query(
element,
"gr-button[data-action-key='review']"
);
assert.isNotOk(approveButtonUpdated);
assert.isTrue(element._hideQuickApproveAction);
});
test('is first in list of secondary actions', () => {
const approveButton = element.$.secondaryActions.querySelector(
'gr-button'
);
assert.equal(approveButton!.getAttribute('data-label'), 'foo+1');
});
test('not added when change is merged', async () => {
element.change = {
...element.change!,
status: ChangeStatus.MERGED,
};
await flush();
const approveButton = query(
element,
"gr-button[data-action-key='review']"
);
assert.isNotOk(approveButton);
});
test('not added when already approved', async () => {
element.change = {
...createChangeViewChange(),
current_revision: 'abc1234' as CommitId,
labels: {
foo: {
approved: {},
values: {},
},
},
permitted_labels: {
foo: [' 0', '+1'],
},
};
await flush();
const approveButton = query(
element,
"gr-button[data-action-key='review']"
);
assert.isNotOk(approveButton);
});
test('not added when label not permitted', async () => {
element.change = {
...createChangeViewChange(),
current_revision: 'abc1234' as CommitId,
labels: {
foo: {values: {}},
},
permitted_labels: {
bar: [],
},
};
await flush();
const approveButton = query(
element,
"gr-button[data-action-key='review']"
);
assert.isNotOk(approveButton);
});
test('approves when tapped', async () => {
const fireActionStub = sinon.stub(element, '_fireAction');
tap(queryAndAssert(element, "gr-button[data-action-key='review']"));
await flush();
assert.isTrue(fireActionStub.called);
assert.isTrue(fireActionStub.calledWith('/review'));
const payload = fireActionStub.lastCall.args[3];
assert.deepEqual((payload as ReviewInput).labels, {foo: 1});
});
test('not added when multiple labels are required without code review', async () => {
element.change = {
...createChangeViewChange(),
current_revision: 'abc1234' as CommitId,
labels: {
foo: {values: {}},
bar: {values: {}},
},
permitted_labels: {
foo: [' 0', '+1'],
bar: [' 0', '+1', '+2'],
},
};
await flush();
const approveButton = query(
element,
"gr-button[data-action-key='review']"
);
assert.isNotOk(approveButton);
});
test('code review shown with multiple missing approval', async () => {
element.change = {
...createChangeViewChange(),
current_revision: 'abc1234' as CommitId,
labels: {
foo: {values: {}},
bar: {values: {}},
'Code-Review': {
approved: {},
values: {
' 0': '',
'+1': '',
'+2': '',
},
},
},
permitted_labels: {
foo: [' 0', '+1'],
bar: [' 0', '+1', '+2'],
'Code-Review': [' 0', '+1', '+2'],
},
};
await flush();
const approveButton = queryAndAssert(
element,
"gr-button[data-action-key='review']"
);
assert.isOk(approveButton);
});
test('button label for missing approval', async () => {
element.change = {
...createChangeViewChange(),
current_revision: 'abc1234' as CommitId,
labels: {
foo: {
values: {
' 0': '',
'+1': '',
},
},
bar: {approved: {}, values: {}},
},
permitted_labels: {
foo: [' 0', '+1'],
bar: [' 0', '+1', '+2'],
},
};
await flush();
const approveButton = queryAndAssert(
element,
"gr-button[data-action-key='review']"
);
assert.equal(approveButton.getAttribute('data-label'), 'foo+1');
});
test('no quick approve if score is not maximal for a label', async () => {
element.change = {
...createChangeViewChange(),
current_revision: 'abc1234' as CommitId,
labels: {
bar: {
value: 1,
values: {
' 0': '',
'+1': '',
'+2': '',
},
},
},
permitted_labels: {
bar: [' 0', '+1'],
},
};
await flush();
const approveButton = query(
element,
"gr-button[data-action-key='review']"
);
assert.isNotOk(approveButton);
});
test('approving label with a non-max score', async () => {
element.change = {
...createChangeViewChange(),
current_revision: 'abc1234' as CommitId,
labels: {
bar: {
value: 1,
values: {
' 0': '',
'+1': '',
'+2': '',
},
},
},
permitted_labels: {
bar: [' 0', '+1', '+2'],
},
};
await flush();
const approveButton = queryAndAssert(
element,
"gr-button[data-action-key='review']"
);
assert.equal(approveButton.getAttribute('data-label'), 'bar+2');
});
test('added when can approve an already-approved code review label', async () => {
element.change = {
...createChangeViewChange(),
current_revision: 'abc1234' as CommitId,
labels: {
'Code-Review': {
approved: {},
values: {
' 0': '',
'+1': '',
'+2': '',
},
},
},
permitted_labels: {
'Code-Review': [' 0', '+1', '+2'],
},
};
await flush();
const approveButton = queryAndAssert(
element,
"gr-button[data-action-key='review']"
);
assert.isNotNull(approveButton);
});
test('not added when the user has already approved', async () => {
const vote = {
...createApproval(),
_account_id: 123 as AccountId,
name: 'name',
value: 2,
};
element.change = {
...createChangeViewChange(),
current_revision: 'abc1234' as CommitId,
labels: {
'Code-Review': {
approved: {},
values: {
' 0': '',
'+1': '',
'+2': '',
},
all: [vote],
},
},
permitted_labels: {
'Code-Review': [' 0', '+1', '+2'],
},
};
await flush();
const approveButton = query(
element,
"gr-button[data-action-key='review']"
);
assert.isNotOk(approveButton);
});
test('not added when user owns the change', async () => {
element.change = {
...createChangeViewChange(),
current_revision: 'abc1234' as CommitId,
owner: createAccountWithId(123),
labels: {
'Code-Review': {
approved: {},
values: {
' 0': '',
'+1': '',
'+2': '',
},
},
},
permitted_labels: {
'Code-Review': [' 0', '+1', '+2'],
},
};
await flush();
const approveButton = query(
element,
"gr-button[data-action-key='review']"
);
assert.isNotOk(approveButton);
});
});
test('adds download revision action', async () => {
const handler = sinon.stub();
element.addEventListener('download-tap', handler);
assert.ok(element.revisionActions.download);
element._handleDownloadTap();
await flush();
assert.isTrue(handler.called);
});
test('changing changeNum or patchNum does not reload', () => {
const reloadStub = sinon.stub(element, 'reload');
element.changeNum = 123 as NumericChangeId;
assert.isFalse(reloadStub.called);
element.latestPatchNum = 456 as PatchSetNum;
assert.isFalse(reloadStub.called);
});
test('_toSentenceCase', () => {
assert.equal(element._toSentenceCase('blah blah'), 'Blah blah');
assert.equal(element._toSentenceCase('BLAH BLAH'), 'Blah blah');
assert.equal(element._toSentenceCase('b'), 'B');
assert.equal(element._toSentenceCase(''), '');
assert.equal(element._toSentenceCase('!@#$%^&*()'), '!@#$%^&*()');
});
suite('setActionOverflow', () => {
test('move action from overflow', async () => {
assert.isNotOk(query(element, '[data-action-key="cherrypick"]'));
assert.strictEqual(
element.$.moreActions!.items![0].id,
'cherrypick-revision'
);
element.setActionOverflow(ActionType.REVISION, 'cherrypick', false);
await flush();
assert.isOk(query(element, '[data-action-key="cherrypick"]'));
assert.notEqual(
element.$.moreActions!.items![0].id,
'cherrypick-revision'
);
});
test('move action to overflow', async () => {
assert.isOk(query(element, '[data-action-key="submit"]'));
element.setActionOverflow(ActionType.REVISION, 'submit', true);
await flush();
assert.isNotOk(query(element, '[data-action-key="submit"]'));
assert.strictEqual(
element.$.moreActions.items![3].id,
'submit-revision'
);
});
suite('_waitForChangeReachable', () => {
let clock: SinonFakeTimers;
setup(() => {
clock = sinon.useFakeTimers();
});
const makeGetChange = (numTries: number) => () => {
if (numTries === 1) {
return Promise.resolve({
...createChangeViewChange(),
_number: 123 as NumericChangeId,
});
} else {
numTries--;
return Promise.resolve(null);
}
};
const tickAndFlush = async (repetitions: number) => {
for (let i = 1; i <= repetitions; i++) {
clock.tick(1000);
await flush();
}
};
test('succeed', async () => {
stubRestApi('getChange').callsFake(makeGetChange(5));
const promise = element._waitForChangeReachable(
123 as NumericChangeId
);
tickAndFlush(5);
const success = await promise;
assert.isTrue(success);
});
test('fail', async () => {
stubRestApi('getChange').callsFake(makeGetChange(6));
const promise = element._waitForChangeReachable(
123 as NumericChangeId
);
tickAndFlush(6);
const success = await promise;
assert.isFalse(success);
});
});
});
suite('_send', () => {
let cleanup: sinon.SinonStub;
const payload = {foo: 'bar'};
let onShowError: sinon.SinonStub;
let onShowAlert: sinon.SinonStub;
let getResponseObjectStub: sinon.SinonStub;
setup(() => {
cleanup = sinon.stub();
element.changeNum = 42 as NumericChangeId;
element.latestPatchNum = 12 as PatchSetNum;
element.change = {
...createChangeViewChange(),
revisions: createRevisions(element.latestPatchNum as number),
messages: createChangeMessages(1),
};
element.change!._number = 42 as NumericChangeId;
onShowError = sinon.stub();
element.addEventListener('show-error', onShowError);
onShowAlert = sinon.stub();
element.addEventListener('show-alert', onShowAlert);
});
suite('happy path', () => {
let sendStub: sinon.SinonStub;
setup(() => {
stubRestApi('getChangeDetail').returns(
Promise.resolve({
...createChangeViewChange(),
// element has latest info
revisions: createRevisions(element.latestPatchNum as number),
messages: createChangeMessages(1),
})
);
getResponseObjectStub = stubRestApi('getResponseObject');
sendStub = stubRestApi('executeChangeAction').returns(
Promise.resolve(new Response())
);
sinon.stub(GerritNav, 'navigateToChange');
});
test('change action', async () => {
await element._send(
HttpMethod.DELETE,
payload,
'/endpoint',
false,
cleanup,
{} as UIActionInfo
);
assert.isFalse(onShowError.called);
assert.isTrue(cleanup.calledOnce);
assert.isTrue(
sendStub.calledWith(
42,
HttpMethod.DELETE,
'/endpoint',
undefined,
payload
)
);
});
suite('show revert submission dialog', () => {
setup(() => {
element.change!.submission_id = '199' as ChangeSubmissionId;
element.change!.current_revision = '2000' as CommitId;
stubRestApi('getChanges').returns(
Promise.resolve([
{
...createChangeViewChange(),
change_id: '12345678901234' as ChangeId,
topic: 'T' as TopicName,
subject: 'random',
},
{
...createChangeViewChange(),
change_id: '23456' as ChangeId,
topic: 'T' as TopicName,
subject: 'a'.repeat(100),
},
])
);
});
});
suite('single changes revert', () => {
let navigateToSearchQueryStub: sinon.SinonStub;
setup(() => {
getResponseObjectStub.returns(
Promise.resolve({revert_changes: [{change_id: 12345}]})
);
navigateToSearchQueryStub = sinon.stub(
GerritNav,
'navigateToSearchQuery'
);
});
test('revert submission single change', async () => {
await element._send(
HttpMethod.POST,
{message: 'Revert submission'},
'/revert_submission',
false,
cleanup,
{} as UIActionInfo
);
await element._handleResponse(
{
__key: 'revert_submission',
__type: ActionType.CHANGE,
label: 'l',
},
new Response()
);
assert.isTrue(navigateToSearchQueryStub.called);
});
});
suite('multiple changes revert', () => {
let showActionDialogStub: sinon.SinonStub;
let navigateToSearchQueryStub: sinon.SinonStub;
setup(() => {
getResponseObjectStub.returns(
Promise.resolve({
revert_changes: [
{change_id: 12345, topic: 'T'},
{change_id: 23456, topic: 'T'},
],
})
);
showActionDialogStub = sinon.stub(element, '_showActionDialog');
navigateToSearchQueryStub = sinon.stub(
GerritNav,
'navigateToSearchQuery'
);
});
test('revert submission multiple change', async () => {
await element._send(
HttpMethod.POST,
{message: 'Revert submission'},
'/revert_submission',
false,
cleanup,
{} as UIActionInfo
);
await element._handleResponse(
{
__key: 'revert_submission',
__type: ActionType.CHANGE,
label: 'l',
},
new Response()
);
assert.isFalse(showActionDialogStub.called);
assert.isTrue(navigateToSearchQueryStub.calledWith('topic: T'));
});
});
test('revision action', async () => {
await element._send(
HttpMethod.DELETE,
payload,
'/endpoint',
true,
cleanup,
{} as UIActionInfo
);
assert.isFalse(onShowError.called);
assert.isTrue(cleanup.calledOnce);
assert.isTrue(
sendStub.calledWith(42, 'DELETE', '/endpoint', 12, payload)
);
});
});
suite('failure modes', () => {
test('non-latest', () => {
stubRestApi('getChangeDetail').returns(
Promise.resolve({
...createChangeViewChange(),
// new patchset was uploaded
revisions: createRevisions(
(element.latestPatchNum as number) + 1
),
messages: createChangeMessages(1),
})
);
const sendStub = stubRestApi('executeChangeAction');
return element
._send(
HttpMethod.DELETE,
payload,
'/endpoint',
true,
cleanup,
{} as UIActionInfo
)
.then(() => {
assert.isTrue(onShowAlert.calledOnce);
assert.isFalse(onShowError.called);
assert.isTrue(cleanup.calledOnce);
assert.isFalse(sendStub.called);
});
});
test('send fails', () => {
stubRestApi('getChangeDetail').returns(
Promise.resolve({
...createChangeViewChange(),
// element has latest info
revisions: createRevisions(element.latestPatchNum as number),
messages: createChangeMessages(1),
})
);
const sendStub = stubRestApi('executeChangeAction').callsFake(
(_num, _method, _patchNum, _endpoint, _payload, onErr) => {
onErr!();
return Promise.resolve(undefined);
}
);
const handleErrorStub = sinon.stub(element, '_handleResponseError');
return element
._send(
HttpMethod.DELETE,
payload,
'/endpoint',
true,
cleanup,
{} as UIActionInfo
)
.then(() => {
assert.isFalse(onShowError.called);
assert.isTrue(cleanup.called);
assert.isTrue(sendStub.calledOnce);
assert.isTrue(handleErrorStub.called);
});
});
});
});
test('_handleAction reports', () => {
sinon.stub(element, '_fireAction');
sinon.stub(element, '_handleChangeAction');
const reportStub = stubReporting('reportInteraction');
element._handleAction(ActionType.CHANGE, 'key');
assert.isTrue(reportStub.called);
assert.equal(reportStub.lastCall.args[0], 'change-key');
});
});
suite('getChangeRevisionActions returns only some actions', () => {
let element: GrChangeActions;
let changeRevisionActions: ActionNameToActionInfoMap = {};
setup(() => {
stubRestApi('getChangeRevisionActions').returns(
Promise.resolve(changeRevisionActions)
);
stubRestApi('send').returns(Promise.reject(new Error('error')));
sinon
.stub(getPluginLoader(), 'awaitPluginsLoaded')
.returns(Promise.resolve());
element = basicFixture.instantiate();
// getChangeRevisionActions is not called without
// set the following properties
element.change = createChangeViewChange();
element.changeNum = 42 as NumericChangeId;
element.latestPatchNum = 2 as PatchSetNum;
stubRestApi('getRepoBranches').returns(Promise.resolve([]));
return element.reload();
});
test('confirmSubmitDialog and confirmRebase properties are changed', () => {
changeRevisionActions = {};
element.reload();
assert.strictEqual(element.$.confirmSubmitDialog.action, null);
assert.strictEqual(element.$.confirmRebase.rebaseOnCurrent, null);
});
test('_computeRebaseOnCurrent', () => {
const rebaseAction = {
enabled: true,
label: 'Rebase',
method: HttpMethod.POST,
title: 'Rebase onto tip of branch or parent change',
};
// When rebase is enabled initially, rebaseOnCurrent should be set to
// true.
assert.isTrue(element._computeRebaseOnCurrent(rebaseAction));
rebaseAction.enabled = false;
// When rebase is not enabled initially, rebaseOnCurrent should be set to
// false.
assert.isFalse(element._computeRebaseOnCurrent(rebaseAction));
});
});
});