blob: 1481c2d8fad121bf55664bc41da2dcbb45c5d561 [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.js';
import './gr-js-api-interface.js';
import {GrPopupInterface} from '../../plugins/gr-popup-interface/gr-popup-interface.js';
import {GrSettingsApi} from '../../plugins/gr-settings-api/gr-settings-api.js';
import {EventType} from '../../plugins/gr-plugin-types.js';
import {PLUGIN_LOADING_TIMEOUT_MS} from './gr-api-utils.js';
import {getPluginLoader} from './gr-plugin-loader.js';
import {_testOnly_initGerritPluginApi} from './gr-gerrit.js';
import {stubBaseUrl} from '../../../test/test-utils.js';
import sinon from 'sinon/pkg/sinon-esm';
const basicFixture = fixtureFromElement('gr-js-api-interface');
const pluginApi = _testOnly_initGerritPluginApi();
suite('gr-js-api-interface tests', () => {
let element;
let plugin;
let errorStub;
let getResponseObjectStub;
let sendStub;
let clock;
const throwErrFn = function() {
throw Error('Unfortunately, this handler has stopped');
};
setup(() => {
clock = sinon.useFakeTimers();
getResponseObjectStub = sinon.stub().returns(Promise.resolve());
sendStub = sinon.stub().returns(Promise.resolve({status: 200}));
stub('gr-rest-api-interface', {
getAccount() {
return Promise.resolve({name: 'Judy Hopps'});
},
getResponseObject: getResponseObjectStub,
send(...args) {
return sendStub(...args);
},
});
element = basicFixture.instantiate();
errorStub = sinon.stub(element.reporting, 'error');
pluginApi.install(p => { plugin = p; }, '0.1',
'http://test.com/plugins/testplugin/static/test.js');
getPluginLoader().loadPlugins([]);
});
teardown(() => {
clock.restore();
element._removeEventCallbacks();
plugin = null;
});
test('url', () => {
assert.equal(plugin.url(), 'http://test.com/plugins/testplugin/');
assert.equal(plugin.url('/static/test.js'),
'http://test.com/plugins/testplugin/static/test.js');
});
test('url for preloaded plugin without ASSETS_PATH', () => {
let plugin;
pluginApi.install(p => { plugin = p; }, '0.1',
'preloaded:testpluginB');
assert.equal(plugin.url(),
`${window.location.origin}/plugins/testpluginB/`);
assert.equal(plugin.url('/static/test.js'),
`${window.location.origin}/plugins/testpluginB/static/test.js`);
});
test('url for preloaded plugin without ASSETS_PATH', () => {
const oldAssetsPath = window.ASSETS_PATH;
window.ASSETS_PATH = 'http://test.com';
let plugin;
pluginApi.install(p => { plugin = p; }, '0.1',
'preloaded:testpluginC');
assert.equal(plugin.url(), `${window.ASSETS_PATH}/plugins/testpluginC/`);
assert.equal(plugin.url('/static/test.js'),
`${window.ASSETS_PATH}/plugins/testpluginC/static/test.js`);
window.ASSETS_PATH = oldAssetsPath;
});
test('_send on failure rejects with response text', () => {
sendStub.returns(Promise.resolve(
{status: 400, text() { return Promise.resolve('text'); }}));
return plugin._send().catch(r => {
assert.equal(r.message, 'text');
});
});
test('_send on failure without text rejects with code', () => {
sendStub.returns(Promise.resolve(
{status: 400, text() { return Promise.resolve(null); }}));
return plugin._send().catch(r => {
assert.equal(r.message, '400');
});
});
test('get', () => {
const response = {foo: 'foo'};
getResponseObjectStub.returns(Promise.resolve(response));
return plugin.get('/url', r => {
assert.isTrue(sendStub.calledWith(
'GET', 'http://test.com/plugins/testplugin/url'));
assert.strictEqual(r, response);
});
});
test('get using Promise', () => {
const response = {foo: 'foo'};
getResponseObjectStub.returns(Promise.resolve(response));
return plugin.get('/url', r => 'rubbish').then(r => {
assert.isTrue(sendStub.calledWith(
'GET', 'http://test.com/plugins/testplugin/url'));
assert.strictEqual(r, response);
});
});
test('post', () => {
const payload = {foo: 'foo'};
const response = {bar: 'bar'};
getResponseObjectStub.returns(Promise.resolve(response));
return plugin.post('/url', payload, r => {
assert.isTrue(sendStub.calledWith(
'POST', 'http://test.com/plugins/testplugin/url', payload));
assert.strictEqual(r, response);
});
});
test('put', () => {
const payload = {foo: 'foo'};
const response = {bar: 'bar'};
getResponseObjectStub.returns(Promise.resolve(response));
return plugin.put('/url', payload, r => {
assert.isTrue(sendStub.calledWith(
'PUT', 'http://test.com/plugins/testplugin/url', payload));
assert.strictEqual(r, response);
});
});
test('delete works', () => {
const response = {status: 204};
sendStub.returns(Promise.resolve(response));
return plugin.delete('/url', r => {
assert.equal(sendStub.lastCall.args[0], 'DELETE');
assert.equal(
sendStub.lastCall.args[1],
'http://test.com/plugins/testplugin/url'
);
assert.strictEqual(r, response);
});
});
test('delete fails', () => {
sendStub.returns(Promise.resolve(
{status: 400, text() { return Promise.resolve('text'); }}));
return plugin.delete('/url', r => {
throw new Error('Should not resolve');
}).catch(err => {
assert.equal(sendStub.lastCall.args[0], 'DELETE');
assert.equal(
sendStub.lastCall.args[1],
'http://test.com/plugins/testplugin/url'
);
assert.equal('text', err.message);
});
});
test('history event', async () => {
let resolve;
const promise = new Promise(r => resolve = r);
plugin.on(EventType.HISTORY, throwErrFn);
plugin.on(EventType.HISTORY, resolve);
element.handleEvent(EventType.HISTORY, {path: '/path/to/awesomesauce'});
const path = await promise;
assert.equal(path, '/path/to/awesomesauce');
assert.isTrue(errorStub.calledOnce);
});
test('showchange event', async () => {
let resolve;
const promise = new Promise(r => resolve = r);
const testChange = {
_number: 42,
revisions: {def: {_number: 2}, abc: {_number: 1}},
};
const expectedChange = {mergeable: false, ...testChange};
plugin.on(EventType.SHOW_CHANGE, throwErrFn);
plugin.on(EventType.SHOW_CHANGE, (change, revision, info) => {
resolve({change, revision, info});
});
element.handleEvent(EventType.SHOW_CHANGE,
{change: testChange, patchNum: 1, info: {mergeable: false}});
const {change, revision, info} = await promise;
assert.deepEqual(change, expectedChange);
assert.deepEqual(revision, testChange.revisions.abc);
assert.deepEqual(info, {mergeable: false});
assert.isTrue(errorStub.calledOnce);
});
test('show-revision-actions event', async () => {
let resolve;
const promise = new Promise(r => resolve = r);
const testChange = {
_number: 42,
revisions: {def: {_number: 2}, abc: {_number: 1}},
};
plugin.on(EventType.SHOW_REVISION_ACTIONS, throwErrFn);
plugin.on(EventType.SHOW_REVISION_ACTIONS, (actions, change) => {
resolve({change, actions});
});
element.handleEvent(EventType.SHOW_REVISION_ACTIONS,
{change: testChange, revisionActions: {test: {}}});
const {change, actions} = await promise;
assert.deepEqual(change, testChange);
assert.deepEqual(actions, {test: {}});
assert.isTrue(errorStub.calledOnce);
});
test('handleEvent awaits plugins load', async () => {
const testChange = {
_number: 42,
revisions: {def: {_number: 2}, abc: {_number: 1}},
};
const spy = sinon.spy();
getPluginLoader().loadPlugins(['plugins/test.html']);
plugin.on(EventType.SHOW_CHANGE, spy);
element.handleEvent(EventType.SHOW_CHANGE,
{change: testChange, patchNum: 1});
assert.isFalse(spy.called);
// Timeout on loading plugins
clock.tick(PLUGIN_LOADING_TIMEOUT_MS * 2);
await flush();
assert.isTrue(spy.called);
});
test('comment event', async () => {
let resolve;
const promise = new Promise(r => resolve = r);
const testCommentNode = {foo: 'bar'};
plugin.on(EventType.COMMENT, throwErrFn);
plugin.on(EventType.COMMENT, resolve);
element.handleEvent(EventType.COMMENT, {node: testCommentNode});
const commentNode = await promise;
assert.deepEqual(commentNode, testCommentNode);
assert.isTrue(errorStub.calledOnce);
});
test('revert event', () => {
function appendToRevertMsg(c, revertMsg, originalMsg) {
return revertMsg + '\n' + originalMsg.replace(/^/gm, '> ') + '\ninfo';
}
assert.equal(element.modifyRevertMsg(null, 'test', 'origTest'), 'test');
assert.equal(errorStub.callCount, 0);
plugin.on(EventType.REVERT, throwErrFn);
plugin.on(EventType.REVERT, appendToRevertMsg);
assert.equal(element.modifyRevertMsg(null, 'test', 'origTest'),
'test\n> origTest\ninfo');
assert.isTrue(errorStub.calledOnce);
plugin.on(EventType.REVERT, appendToRevertMsg);
assert.equal(element.modifyRevertMsg(null, 'test', 'origTest'),
'test\n> origTest\ninfo\n> origTest\ninfo');
assert.isTrue(errorStub.calledTwice);
});
test('postrevert event', () => {
function getLabels(c) {
return {'Code-Review': 1};
}
assert.deepEqual(element.getLabelValuesPostRevert(null), {});
assert.equal(errorStub.callCount, 0);
plugin.on(EventType.POST_REVERT, throwErrFn);
plugin.on(EventType.POST_REVERT, getLabels);
assert.deepEqual(
element.getLabelValuesPostRevert(null), {'Code-Review': 1});
assert.isTrue(errorStub.calledOnce);
});
test('commitmsgedit event', async () => {
let resolve;
const promise = new Promise(r => resolve = r);
const testMsg = 'Test CL commit message';
plugin.on(EventType.COMMIT_MSG_EDIT, throwErrFn);
plugin.on(EventType.COMMIT_MSG_EDIT, (change, msg) => {
resolve(msg);
});
element.handleCommitMessage(null, testMsg);
const msg = await promise;
assert.deepEqual(msg, testMsg);
assert.isTrue(errorStub.calledOnce);
});
test('labelchange event', async () => {
let resolve;
const promise = new Promise(r => resolve = r);
const testChange = {_number: 42};
plugin.on(EventType.LABEL_CHANGE, throwErrFn);
plugin.on(EventType.LABEL_CHANGE, resolve);
element.handleEvent(EventType.LABEL_CHANGE, {change: testChange});
const change = await promise;
assert.deepEqual(change, testChange);
assert.isTrue(errorStub.calledOnce);
});
test('submitchange', () => {
plugin.on(EventType.SUBMIT_CHANGE, throwErrFn);
plugin.on(EventType.SUBMIT_CHANGE, () => true);
assert.isTrue(element.canSubmitChange());
assert.isTrue(errorStub.calledOnce);
plugin.on(EventType.SUBMIT_CHANGE, () => false);
plugin.on(EventType.SUBMIT_CHANGE, () => true);
assert.isFalse(element.canSubmitChange());
assert.isTrue(errorStub.calledTwice);
});
test('highlightjs-loaded event', async () => {
let resolve;
const promise = new Promise(r => resolve = r);
const testHljs = {_number: 42};
plugin.on(EventType.HIGHLIGHTJS_LOADED, throwErrFn);
plugin.on(EventType.HIGHLIGHTJS_LOADED, resolve);
element.handleEvent(EventType.HIGHLIGHTJS_LOADED, {hljs: testHljs});
const hljs = await promise;
assert.deepEqual(hljs, testHljs);
assert.isTrue(errorStub.calledOnce);
});
test('getLoggedIn', () => {
// fake fetch for authCheck
sinon.stub(window, 'fetch').callsFake(() => Promise.resolve({status: 204}));
return plugin.restApi().getLoggedIn()
.then(loggedIn => {
assert.isTrue(loggedIn);
});
});
test('attributeHelper', () => {
assert.isOk(plugin.attributeHelper());
});
test('getAdminMenuLinks', () => {
const links = [{text: 'a', url: 'b'}, {text: 'c', url: 'd'}];
const getCallbacksStub = sinon.stub(element, '_getEventCallbacks')
.returns([
{getMenuLinks: () => [links[0]]},
{getMenuLinks: () => [links[1]]},
]);
const result = element.getAdminMenuLinks();
assert.deepEqual(result, links);
assert.isTrue(getCallbacksStub.calledOnce);
assert.equal(getCallbacksStub.lastCall.args[0],
EventType.ADMIN_MENU_LINKS);
});
suite('test plugin with base url', () => {
let baseUrlPlugin;
setup(() => {
stubBaseUrl('/r');
pluginApi.install(p => { baseUrlPlugin = p; }, '0.1',
'http://test.com/r/plugins/baseurlplugin/static/test.js');
});
test('url', () => {
assert.notEqual(baseUrlPlugin.url(),
'http://test.com/plugins/baseurlplugin/');
assert.equal(baseUrlPlugin.url(),
'http://test.com/r/plugins/baseurlplugin/');
assert.equal(baseUrlPlugin.url('/static/test.js'),
'http://test.com/r/plugins/baseurlplugin/static/test.js');
});
});
suite('popup', () => {
test('popup(element) is deprecated', () => {
sinon.stub(console, 'error');
plugin.popup(document.createElement('div'));
assert.isTrue(console.error.calledOnce);
});
test('popup(moduleName) creates popup with component', () => {
const openStub = sinon.stub(GrPopupInterface.prototype, 'open').callsFake(
function() {
// Arrow function can't be used here, because we want to
// get properties from the instance of GrPopupInterface
// eslint-disable-next-line no-invalid-this
const grPopupInterface = this;
assert.equal(grPopupInterface.plugin, plugin);
assert.equal(grPopupInterface._moduleName, 'some-name');
});
plugin.popup('some-name');
assert.isTrue(openStub.calledOnce);
});
});
suite('screen', () => {
test('screenUrl()', () => {
stubBaseUrl('/base');
assert.equal(
plugin.screenUrl(),
`${location.origin}/base/x/testplugin`
);
assert.equal(
plugin.screenUrl('foo'),
`${location.origin}/base/x/testplugin/foo`
);
});
test('works', () => {
sinon.stub(plugin, 'registerCustomComponent');
plugin.screen('foo', 'some-module');
assert.isTrue(plugin.registerCustomComponent.calledWith(
'testplugin-screen-foo', 'some-module'));
});
});
suite('settingsScreen', () => {
test('plugin.settings() returns GrSettingsApi', () => {
assert.isOk(plugin.settings());
assert.isTrue(plugin.settings() instanceof GrSettingsApi);
});
});
});