blob: 95ac40f9e42bb7e69029cb021c873b904e589284 [file] [log] [blame]
/**
* @license
* Copyright 2018 Google LLC
* SPDX-License-Identifier: Apache-2.0
*/
import '../../../test/common-test-setup-karma';
import './gr-diff-host';
import {
CommentSide,
createDefaultDiffPrefs,
Side,
} from '../../../constants/constants';
import {
createAccountDetailWithId,
createBlame,
createChange,
createComment,
createCommentThread,
createDiff,
createPatchRange,
createRunResult,
} from '../../../test/test-data-generators';
import {
addListenerForTest,
mockPromise,
query,
queryAll,
queryAndAssert,
stubReporting,
stubRestApi,
} from '../../../test/test-utils';
import {
BasePatchSetNum,
BlameInfo,
CommentRange,
CommitId,
EDIT,
ImageInfo,
NumericChangeId,
PARENT,
PatchSetNum,
RepoName,
RevisionPatchSetNum,
UrlEncodedCommentId,
} from '../../../types/common';
import {CoverageType} from '../../../types/types';
import {GerritNav} from '../../core/gr-navigation/gr-navigation';
import {GrDiffBuilderImage} from '../../../embed/diff/gr-diff-builder/gr-diff-builder-image';
import {GrDiffHost, LineInfo} from './gr-diff-host';
import {DiffInfo, DiffViewMode, IgnoreWhitespaceType} from '../../../api/diff';
import {ErrorCallback} from '../../../api/rest';
import {SinonStub} from 'sinon';
import {RunResult} from '../../../models/checks/checks-model';
import {GrCommentThread} from '../../shared/gr-comment-thread/gr-comment-thread';
import {assertIsDefined} from '../../../utils/common-util';
import {GrAnnotationActionsInterface} from '../../shared/gr-js-api-interface/gr-annotation-actions-js-api';
const basicFixture = fixtureFromElement('gr-diff-host');
suite('gr-diff-host tests', () => {
let element: GrDiffHost;
let account = createAccountDetailWithId(1);
let getDiffRestApiStub: SinonStub;
setup(async () => {
stubRestApi('getAccount').callsFake(() => Promise.resolve(account));
element = basicFixture.instantiate();
element.changeNum = 123 as NumericChangeId;
element.path = 'some/path';
element.change = createChange();
element.patchRange = createPatchRange();
getDiffRestApiStub = stubRestApi('getDiff');
// Fall back in case a test forgets to set one up
getDiffRestApiStub.returns(Promise.resolve(createDiff()));
await element.updateComplete;
});
suite('plugin layers', () => {
let getDiffLayersStub: sinon.SinonStub;
const pluginLayers = [{annotate: () => {}}, {annotate: () => {}}];
setup(async () => {
element = basicFixture.instantiate();
getDiffLayersStub = sinon
.stub(element.jsAPI, 'getDiffLayers')
.returns(pluginLayers);
element.changeNum = 123 as NumericChangeId;
element.change = createChange();
element.patchRange = createPatchRange();
element.path = 'some/path';
await element.updateComplete;
});
test('plugin layers requested', async () => {
getDiffRestApiStub.returns(Promise.resolve(createDiff()));
await element.reload();
assert(getDiffLayersStub.called);
});
});
suite('render reporting', () => {
test('ends total and syntax timer after syntax layer', async () => {
const displayedStub = stubReporting('diffViewContentDisplayed');
element.patchRange = createPatchRange();
element.change = createChange();
element.prefs = createDefaultDiffPrefs();
await element.updateComplete;
// Force a reload because it's not possible to wait on the reload called
// from update().
await element.reload();
const timeEndStub = sinon.stub(element.reporting, 'timeEnd');
let notifySyntaxProcessed: () => void = () => {};
sinon.stub(element.syntaxLayer, 'process').returns(
new Promise(resolve => {
notifySyntaxProcessed = resolve;
})
);
const promise = element.reload(true);
// Multiple cascading microtasks are scheduled.
notifySyntaxProcessed();
await element.updateComplete;
await promise;
const calls = timeEndStub.getCalls();
assert.equal(calls.length, 4);
assert.equal(calls[0].args[0], 'Diff Load Render');
assert.equal(calls[1].args[0], 'Diff Content Render');
assert.equal(calls[2].args[0], 'Diff Syntax Render');
assert.equal(calls[3].args[0], 'Diff Total Render');
assert.isTrue(displayedStub.called);
});
test('completes reload promise after syntax layer processing', async () => {
let notifySyntaxProcessed: () => void = () => {};
sinon.stub(element.syntaxLayer, 'process').returns(
new Promise(resolve => {
notifySyntaxProcessed = resolve;
})
);
getDiffRestApiStub.returns(Promise.resolve(createDiff()));
element.patchRange = createPatchRange();
element.change = createChange();
let reloadComplete = false;
element.prefs = createDefaultDiffPrefs();
const promise = mockPromise();
element.reload().then(() => {
reloadComplete = true;
promise.resolve();
});
// Multiple cascading microtasks are scheduled.
assert.isFalse(reloadComplete);
notifySyntaxProcessed();
await promise;
assert.isTrue(reloadComplete);
});
});
test('reload() cancels before network resolves', async () => {
assertIsDefined(element.diffElement);
const cancelStub = sinon.stub(element.diffElement, 'cancel');
// Stub the network calls into requests that never resolve.
sinon.stub(element, 'getDiff').callsFake(() => new Promise(() => {}));
element.patchRange = createPatchRange();
element.change = createChange();
element.prefs = undefined;
// Needs to be set to something first for it to cancel.
element.diff = createDiff();
await element.updateComplete;
element.reload();
assert.isTrue(cancelStub.called);
});
test('reload() loads files weblinks', async () => {
element.change = createChange();
const weblinksStub = sinon
.stub(GerritNav, '_generateWeblinks')
.returns({name: 'stubb', url: '#s'});
getDiffRestApiStub.returns(Promise.resolve(createDiff()));
element.projectName = 'test-project' as RepoName;
element.path = 'test-path';
element.commitRange = {
baseCommit: 'test-base' as CommitId,
commit: 'test-commit' as CommitId,
};
element.patchRange = createPatchRange();
await element.reload();
assert.equal(weblinksStub.callCount, 3);
assert.deepEqual(weblinksStub.firstCall.args[0], {
commit: 'test-base' as CommitId,
file: 'test-path',
options: {
weblinks: undefined,
},
repo: 'test-project' as RepoName,
type: GerritNav.WeblinkType.EDIT,
});
assert.deepEqual(element.editWeblinks, [
{
name: 'stubb',
url: '#s',
},
]);
assert.deepEqual(weblinksStub.secondCall.args[0], {
commit: 'test-base' as CommitId,
file: 'test-path',
options: {
weblinks: undefined,
},
repo: 'test-project' as RepoName,
type: GerritNav.WeblinkType.FILE,
});
assert.deepEqual(weblinksStub.thirdCall.args[0], {
commit: 'test-commit' as CommitId,
file: 'test-path',
options: {
weblinks: undefined,
},
repo: 'test-project' as RepoName,
type: GerritNav.WeblinkType.FILE,
});
assert.deepEqual(element.filesWeblinks, {
meta_a: [{name: 'stubb', url: '#s'}],
meta_b: [{name: 'stubb', url: '#s'}],
});
});
test('prefetch getDiff', async () => {
getDiffRestApiStub.returns(Promise.resolve(createDiff()));
element.changeNum = 123 as NumericChangeId;
element.patchRange = createPatchRange();
element.path = 'file.txt';
element.prefetchDiff();
await element.getDiff();
assert.isTrue(getDiffRestApiStub.calledOnce);
});
test('getDiff handles undefined diff responses', async () => {
getDiffRestApiStub.returns(Promise.resolve(undefined));
element.changeNum = 123 as NumericChangeId;
element.patchRange = createPatchRange();
element.path = 'file.txt';
await element.getDiff();
});
test('reload resolves on error', () => {
const onErrStub = sinon.stub(element, 'handleGetDiffError');
const error = new Response(null, {status: 500});
getDiffRestApiStub.callsFake(
(
_1: NumericChangeId,
_2: PatchSetNum,
_3: PatchSetNum,
_4: string,
_5?: IgnoreWhitespaceType,
onErr?: ErrorCallback
) => {
if (onErr) onErr(error);
return Promise.resolve(undefined);
}
);
element.patchRange = createPatchRange();
return element.reload().then(() => {
assert.isTrue(onErrStub.calledOnce);
});
});
suite('handleGetDiffError', () => {
let serverErrorStub: sinon.SinonStub;
let pageErrorStub: sinon.SinonStub;
setup(() => {
serverErrorStub = sinon.stub();
addListenerForTest(document, 'server-error', serverErrorStub);
pageErrorStub = sinon.stub();
addListenerForTest(document, 'page-error', pageErrorStub);
});
test('page error on HTTP-409', () => {
element.handleGetDiffError({status: 409} as Response);
assert.isTrue(serverErrorStub.calledOnce);
assert.isFalse(pageErrorStub.called);
assert.isNotOk(element.errorMessage);
});
test('server error on non-HTTP-409', () => {
element.handleGetDiffError({
status: 500,
text: () => Promise.resolve(''),
} as Response);
assert.isFalse(serverErrorStub.called);
assert.isTrue(pageErrorStub.calledOnce);
assert.isNotOk(element.errorMessage);
});
test('error message if showLoadFailure', () => {
element.showLoadFailure = true;
element.handleGetDiffError({
status: 500,
statusText: 'Failure!',
} as Response);
assert.isFalse(serverErrorStub.called);
assert.isFalse(pageErrorStub.called);
assert.equal(
element.errorMessage,
'Encountered error when loading the diff: 500 Failure!'
);
});
});
suite('image diffs', () => {
let mockFile1: ImageInfo;
let mockFile2: ImageInfo;
setup(() => {
mockFile1 = {
body:
'Qk06AAAAAAAAADYAAAAoAAAAAQAAAP////8BACAAAAAAAAAAAAATCwAAE' +
'wsAAAAAAAAAAAAAAAAA/w==',
type: 'image/bmp',
_expectedType: 'image/bmp',
_name: 'carrot.bmp',
};
mockFile2 = {
body:
'Qk06AAAAAAAAADYAAAAoAAAAAQAAAP////8BACAAAAAAAAAAAAATCwAAE' +
'wsAAAAAAAAAAAAA/////w==',
type: 'image/bmp',
_expectedType: 'image/bmp',
_name: 'potato.bmp',
};
element.patchRange = createPatchRange();
element.change = createChange();
});
test('renders image diffs with same file name', async () => {
const mockDiff: DiffInfo = {
meta_a: {name: 'carrot.jpg', content_type: 'image/jpeg', lines: 66},
meta_b: {name: 'carrot.jpg', content_type: 'image/jpeg', lines: 560},
intraline_status: 'OK',
change_type: 'MODIFIED',
diff_header: [
'diff --git a/carrot.jpg b/carrot.jpg',
'index 2adc47d..f9c2f2c 100644',
'--- a/carrot.jpg',
'+++ b/carrot.jpg',
'Binary files differ',
],
content: [{skip: 66}],
binary: true,
};
getDiffRestApiStub.returns(Promise.resolve(mockDiff));
stubRestApi('getImagesForDiff').returns(
Promise.resolve({
baseImage: {
...mockFile1,
_expectedType: 'image/jpeg',
_name: 'carrot.jpg',
},
revisionImage: {
...mockFile2,
_expectedType: 'image/jpeg',
_name: 'carrot.jpg',
},
})
);
element.prefs = createDefaultDiffPrefs();
element.reload();
await element.waitForReloadToRender();
// Recognizes that it should be an image diff.
assert.isTrue(element.isImageDiff);
assertIsDefined(element.diffElement);
assert.instanceOf(
element.diffElement.diffBuilder.builder,
GrDiffBuilderImage
);
// Left image rendered with the parent commit's version of the file.
assertIsDefined(element.diffElement);
const diffTable = element.diffElement.$.diffTable;
const leftImage = queryAndAssert(diffTable, 'td.left img');
const leftLabel = queryAndAssert(diffTable, 'td.left label');
const leftLabelContent = leftLabel.querySelector('.label');
const leftLabelName = leftLabel.querySelector('.name');
const rightImage = queryAndAssert(diffTable, 'td.right img');
const rightLabel = queryAndAssert(diffTable, 'td.right label');
const rightLabelContent = rightLabel.querySelector('.label');
const rightLabelName = rightLabel.querySelector('.name');
assert.isOk(leftImage);
assert.equal(
leftImage.getAttribute('src'),
'data:image/bmp;base64,' + mockFile1.body
);
assert.isTrue(leftLabelContent?.textContent?.includes('image/bmp'));
assert.isNotOk(leftLabelName);
assert.isOk(rightImage);
assert.equal(
rightImage.getAttribute('src'),
'data:image/bmp;base64,' + mockFile2.body
);
assert.isTrue(rightLabelContent?.textContent?.includes('image/bmp'));
assert.isNotOk(rightLabelName);
});
test('renders image diffs with a different file name', async () => {
const mockDiff: DiffInfo = {
meta_a: {name: 'carrot.jpg', content_type: 'image/jpeg', lines: 66},
meta_b: {name: 'carrot2.jpg', content_type: 'image/jpeg', lines: 560},
intraline_status: 'OK',
change_type: 'MODIFIED',
diff_header: [
'diff --git a/carrot.jpg b/carrot2.jpg',
'index 2adc47d..f9c2f2c 100644',
'--- a/carrot.jpg',
'+++ b/carrot2.jpg',
'Binary files differ',
],
content: [{skip: 66}],
binary: true,
};
getDiffRestApiStub.returns(Promise.resolve(mockDiff));
stubRestApi('getImagesForDiff').returns(
Promise.resolve({
baseImage: {
...mockFile1,
_expectedType: 'image/jpeg',
_name: 'carrot.jpg',
},
revisionImage: {
...mockFile2,
_expectedType: 'image/jpeg',
_name: 'carrot2.jpg',
},
})
);
element.prefs = createDefaultDiffPrefs();
element.reload();
await element.waitForReloadToRender();
// Recognizes that it should be an image diff.
assert.isTrue(element.isImageDiff);
assertIsDefined(element.diffElement);
assert.instanceOf(
element.diffElement.diffBuilder.builder,
GrDiffBuilderImage
);
// Left image rendered with the parent commit's version of the file.
const diffTable = element.diffElement.$.diffTable;
const leftImage = queryAndAssert(diffTable, 'td.left img');
const leftLabel = queryAndAssert(diffTable, 'td.left label');
const leftLabelContent = leftLabel.querySelector('.label');
const leftLabelName = leftLabel.querySelector('.name');
const rightImage = queryAndAssert(diffTable, 'td.right img');
const rightLabel = queryAndAssert(diffTable, 'td.right label');
const rightLabelContent = rightLabel.querySelector('.label');
const rightLabelName = rightLabel.querySelector('.name');
assert.isOk(rightLabelName);
assert.isOk(leftLabelName);
assert.equal(leftLabelName?.textContent, mockDiff.meta_a?.name);
assert.equal(rightLabelName?.textContent, mockDiff.meta_b?.name);
assert.isOk(leftImage);
assert.equal(
leftImage.getAttribute('src'),
'data:image/bmp;base64,' + mockFile1.body
);
assert.isTrue(leftLabelContent?.textContent?.includes('image/bmp'));
assert.isOk(rightImage);
assert.equal(
rightImage.getAttribute('src'),
'data:image/bmp;base64,' + mockFile2.body
);
assert.isTrue(rightLabelContent?.textContent?.includes('image/bmp'));
});
test('renders added image', async () => {
const mockDiff: DiffInfo = {
meta_b: {name: 'carrot.jpg', content_type: 'image/jpeg', lines: 560},
intraline_status: 'OK',
change_type: 'ADDED',
diff_header: [
'diff --git a/carrot.jpg b/carrot.jpg',
'index 0000000..f9c2f2c 100644',
'--- /dev/null',
'+++ b/carrot.jpg',
'Binary files differ',
],
content: [{skip: 66}],
binary: true,
};
getDiffRestApiStub.returns(Promise.resolve(mockDiff));
stubRestApi('getImagesForDiff').returns(
Promise.resolve({
baseImage: null,
revisionImage: {
...mockFile2,
_expectedType: 'image/jpeg',
_name: 'carrot2.jpg',
},
})
);
element.prefs = createDefaultDiffPrefs();
element.reload();
await element.waitForReloadToRender().then(() => {
// Recognizes that it should be an image diff.
assert.isTrue(element.isImageDiff);
assertIsDefined(element.diffElement);
assert.instanceOf(
element.diffElement.diffBuilder.builder,
GrDiffBuilderImage
);
const diffTable = element.diffElement.$.diffTable;
const leftImage = query(diffTable, 'td.left img');
const rightImage = queryAndAssert(diffTable, 'td.right img');
assert.isNotOk(leftImage);
assert.isOk(rightImage);
});
});
test('renders removed image', async () => {
const mockDiff: DiffInfo = {
meta_a: {name: 'carrot.jpg', content_type: 'image/jpeg', lines: 560},
intraline_status: 'OK',
change_type: 'DELETED',
diff_header: [
'diff --git a/carrot.jpg b/carrot.jpg',
'index f9c2f2c..0000000 100644',
'--- a/carrot.jpg',
'+++ /dev/null',
'Binary files differ',
],
content: [{skip: 66}],
binary: true,
};
getDiffRestApiStub.returns(Promise.resolve(mockDiff));
stubRestApi('getImagesForDiff').returns(
Promise.resolve({
baseImage: {
...mockFile1,
_expectedType: 'image/jpeg',
_name: 'carrot.jpg',
},
revisionImage: null,
})
);
element.prefs = createDefaultDiffPrefs();
element.reload();
await element.waitForReloadToRender().then(() => {
// Recognizes that it should be an image diff.
assert.isTrue(element.isImageDiff);
assertIsDefined(element.diffElement);
assert.instanceOf(
element.diffElement.diffBuilder.builder,
GrDiffBuilderImage
);
const diffTable = element.diffElement.$.diffTable;
const leftImage = queryAndAssert(diffTable, 'td.left img');
const rightImage = query(diffTable, 'td.right img');
assert.isOk(leftImage);
assert.isNotOk(rightImage);
});
});
test('does not render disallowed image type', async () => {
const mockDiff: DiffInfo = {
meta_a: {
name: 'carrot.jpg',
content_type: 'image/jpeg-evil',
lines: 560,
},
intraline_status: 'OK',
change_type: 'DELETED',
diff_header: [
'diff --git a/carrot.jpg b/carrot.jpg',
'index f9c2f2c..0000000 100644',
'--- a/carrot.jpg',
'+++ /dev/null',
'Binary files differ',
],
content: [{skip: 66}],
binary: true,
};
mockFile1.type = 'image/jpeg-evil';
getDiffRestApiStub.returns(Promise.resolve(mockDiff));
stubRestApi('getImagesForDiff').returns(
Promise.resolve({
baseImage: {
...mockFile1,
_expectedType: 'image/jpeg',
_name: 'carrot.jpg',
},
revisionImage: null,
})
);
element.prefs = createDefaultDiffPrefs();
element.updateComplete.then(() => {
// Recognizes that it should be an image diff.
assert.isTrue(element.isImageDiff);
assertIsDefined(element.diffElement);
assert.instanceOf(
element.diffElement.diffBuilder.builder,
GrDiffBuilderImage
);
const diffTable = element.diffElement.$.diffTable;
const leftImage = query(diffTable, 'td.left img');
assert.isNotOk(leftImage);
});
});
});
test('cannot create comments when not logged in', () => {
element.userModel.setAccount(undefined);
element.patchRange = createPatchRange();
const showAuthRequireSpy = sinon.spy();
element.addEventListener('show-auth-required', showAuthRequireSpy);
element.dispatchEvent(
new CustomEvent('create-comment', {
detail: {
lineNum: 3,
side: Side.LEFT,
path: '/p',
},
})
);
assertIsDefined(element.diffElement);
const threads = queryAll(element.diffElement, 'gr-comment-thread');
assert.equal(threads.length, 0);
assert.isTrue(showAuthRequireSpy.called);
});
test('delegates cancel()', () => {
assertIsDefined(element.diffElement);
const stub = sinon.stub(element.diffElement, 'cancel');
element.patchRange = createPatchRange();
element.cancel();
assert.isTrue(stub.calledOnce);
assert.equal(stub.lastCall.args.length, 0);
});
test('delegates getCursorStops()', () => {
const returnValue = [document.createElement('b')];
assertIsDefined(element.diffElement);
const stub = sinon
.stub(element.diffElement, 'getCursorStops')
.returns(returnValue);
assert.equal(element.getCursorStops(), returnValue);
assert.isTrue(stub.calledOnce);
assert.equal(stub.lastCall.args.length, 0);
});
test('delegates isRangeSelected()', () => {
const returnValue = true;
assertIsDefined(element.diffElement);
const stub = sinon
.stub(element.diffElement, 'isRangeSelected')
.returns(returnValue);
assert.equal(element.isRangeSelected(), returnValue);
assert.isTrue(stub.calledOnce);
assert.equal(stub.lastCall.args.length, 0);
});
test('delegates toggleLeftDiff()', () => {
assertIsDefined(element.diffElement);
const stub = sinon.stub(element.diffElement, 'toggleLeftDiff');
element.toggleLeftDiff();
assert.isTrue(stub.calledOnce);
assert.equal(stub.lastCall.args.length, 0);
});
suite('blame', () => {
setup(async () => {
element = basicFixture.instantiate();
element.changeNum = 123 as NumericChangeId;
element.path = 'some/path';
await element.updateComplete;
});
test('clearBlame', async () => {
element.blame = [];
await element.updateComplete;
assertIsDefined(element.diffElement);
const setBlameSpy = sinon.spy(
element.diffElement.diffBuilder,
'setBlame'
);
const isBlameLoadedStub = sinon.stub();
element.addEventListener('is-blame-loaded-changed', isBlameLoadedStub);
element.clearBlame();
await element.updateComplete;
assert.isNull(element.blame);
assert.isTrue(setBlameSpy.calledWithExactly(null));
assert.isTrue(isBlameLoadedStub.calledOnce);
assert.isFalse(isBlameLoadedStub.args[0][0].detail.value);
});
test('loadBlame', async () => {
const mockBlame: BlameInfo[] = [createBlame()];
const showAlertStub = sinon.stub();
element.addEventListener('show-alert', showAlertStub);
const getBlameStub = stubRestApi('getBlame').returns(
Promise.resolve(mockBlame)
);
const changeNum = 42 as NumericChangeId;
element.changeNum = changeNum;
element.patchRange = createPatchRange();
element.path = 'foo/bar.baz';
await element.updateComplete;
const isBlameLoadedStub = sinon.stub();
element.addEventListener('is-blame-loaded-changed', isBlameLoadedStub);
return element.loadBlame().then(() => {
assert.isTrue(
getBlameStub.calledWithExactly(
changeNum,
1 as RevisionPatchSetNum,
'foo/bar.baz',
true
)
);
assert.isFalse(showAlertStub.called);
assert.equal(element.blame, mockBlame);
assert.isTrue(isBlameLoadedStub.calledOnce);
assert.isTrue(isBlameLoadedStub.args[0][0].detail.value);
});
});
test('loadBlame empty', async () => {
const mockBlame: BlameInfo[] = [];
const showAlertStub = sinon.stub();
const isBlameLoadedStub = sinon.stub();
element.addEventListener('show-alert', showAlertStub);
element.addEventListener('is-blame-loaded-changed', isBlameLoadedStub);
stubRestApi('getBlame').returns(Promise.resolve(mockBlame));
const changeNum = 42 as NumericChangeId;
element.changeNum = changeNum;
element.patchRange = createPatchRange();
element.path = 'foo/bar.baz';
await element.updateComplete;
return element
.loadBlame()
.then(() => {
assert.isTrue(false, 'Promise should not resolve');
})
.catch(() => {
assert.isTrue(showAlertStub.calledOnce);
assert.isNull(element.blame);
// We don't expect a call because
assert.isTrue(isBlameLoadedStub.notCalled);
});
});
});
test('getThreadEls() returns .comment-threads', () => {
const threadEl = document.createElement('gr-comment-thread');
threadEl.className = 'comment-thread';
assertIsDefined(element.diffElement);
element.diffElement.appendChild(threadEl);
assert.deepEqual(element.getThreadEls(), [threadEl]);
});
test('delegates addDraftAtLine(el)', () => {
const param0 = document.createElement('b');
assertIsDefined(element.diffElement);
const stub = sinon.stub(element.diffElement, 'addDraftAtLine');
element.addDraftAtLine(param0);
assert.isTrue(stub.calledOnce);
assert.equal(stub.lastCall.args.length, 1);
assert.equal(stub.lastCall.args[0], param0);
});
test('delegates clearDiffContent()', () => {
assertIsDefined(element.diffElement);
const stub = sinon.stub(element.diffElement, 'clearDiffContent');
element.clearDiffContent();
assert.isTrue(stub.calledOnce);
assert.equal(stub.lastCall.args.length, 0);
});
test('delegates toggleAllContext()', () => {
assertIsDefined(element.diffElement);
const stub = sinon.stub(element.diffElement, 'toggleAllContext');
element.toggleAllContext();
assert.isTrue(stub.calledOnce);
assert.equal(stub.lastCall.args.length, 0);
});
test('passes in noAutoRender', async () => {
const value = true;
element.noAutoRender = value;
await element.updateComplete;
assertIsDefined(element.diffElement);
assert.equal(element.diffElement.noAutoRender, value);
});
test('passes in path', async () => {
const value = 'some/file/path';
element.path = value;
await element.updateComplete;
assertIsDefined(element.diffElement);
assert.equal(element.diffElement.path, value);
});
test('passes in prefs', async () => {
const value = createDefaultDiffPrefs();
element.prefs = value;
await element.updateComplete;
assertIsDefined(element.diffElement);
assert.equal(element.diffElement.prefs, value);
});
test('passes in displayLine', async () => {
const value = true;
element.displayLine = value;
await element.updateComplete;
assertIsDefined(element.diffElement);
assert.equal(element.diffElement.displayLine, value);
});
test('passes in hidden', async () => {
const value = true;
element.hidden = value;
await element.updateComplete;
assertIsDefined(element.diffElement);
assert.equal(element.diffElement.hidden, value);
assert.isNotNull(element.getAttribute('hidden'));
});
test('passes in noRenderOnPrefsChange', async () => {
const value = true;
element.noRenderOnPrefsChange = value;
await element.updateComplete;
assertIsDefined(element.diffElement);
assert.equal(element.diffElement.noRenderOnPrefsChange, value);
});
test('passes in lineWrapping', async () => {
const value = true;
element.lineWrapping = value;
await element.updateComplete;
assertIsDefined(element.diffElement);
assert.equal(element.diffElement.lineWrapping, value);
});
test('passes in viewMode', async () => {
const value = DiffViewMode.SIDE_BY_SIDE;
element.viewMode = value;
await element.updateComplete;
assertIsDefined(element.diffElement);
assert.equal(element.diffElement.viewMode, value);
});
test('passes in lineOfInterest', async () => {
const value = {lineNum: 123, side: Side.LEFT};
element.lineOfInterest = value;
await element.updateComplete;
assertIsDefined(element.diffElement);
assert.equal(element.diffElement.lineOfInterest, value);
});
suite('reportDiff', () => {
let reportStub: SinonStub;
setup(async () => {
element = basicFixture.instantiate();
element.changeNum = 123 as NumericChangeId;
element.path = 'file.txt';
element.patchRange = createPatchRange(1, 2);
reportStub = sinon.stub(element.reporting, 'reportInteraction');
await element.updateComplete;
reportStub.reset();
});
test('undefined', () => {
element.reportDiff(undefined);
assert.isFalse(reportStub.called);
});
test('diff w/ no delta', () => {
const diff: DiffInfo = {
...createDiff(),
content: [{ab: ['foo', 'bar']}, {ab: ['baz', 'foo']}],
};
element.reportDiff(diff);
assert.isTrue(reportStub.calledOnce);
assert.equal(reportStub.lastCall.args[0], 'rebase-percent-zero');
assert.isUndefined(reportStub.lastCall.args[1]);
});
test('diff w/ no rebase delta', () => {
const diff: DiffInfo = {
...createDiff(),
content: [
{ab: ['foo', 'bar']},
{a: ['baz', 'foo']},
{ab: ['foo', 'bar']},
{a: ['baz', 'foo'], b: ['bar', 'baz']},
{ab: ['foo', 'bar']},
{b: ['baz', 'foo']},
{ab: ['foo', 'bar']},
],
};
element.reportDiff(diff);
assert.isTrue(reportStub.calledOnce);
assert.equal(reportStub.lastCall.args[0], 'rebase-percent-zero');
assert.isUndefined(reportStub.lastCall.args[1]);
});
test('diff w/ some rebase delta', () => {
const diff: DiffInfo = {
...createDiff(),
content: [
{ab: ['foo', 'bar']},
{a: ['baz', 'foo'], due_to_rebase: true},
{ab: ['foo', 'bar']},
{a: ['baz', 'foo'], b: ['bar', 'baz']},
{ab: ['foo', 'bar']},
{b: ['baz', 'foo'], due_to_rebase: true},
{ab: ['foo', 'bar']},
{a: ['baz', 'foo']},
],
};
element.reportDiff(diff);
assert.isTrue(reportStub.calledOnce);
assert.isTrue(
reportStub.calledWith('rebase-percent-nonzero', {
percentRebaseDelta: 50,
})
);
});
test('diff w/ all rebase delta', () => {
const diff: DiffInfo = {
...createDiff(),
content: [
{
a: ['foo', 'bar'],
b: ['baz', 'foo'],
due_to_rebase: true,
},
],
};
element.reportDiff(diff);
assert.isTrue(reportStub.calledOnce);
assert.isTrue(
reportStub.calledWith('rebase-percent-nonzero', {
percentRebaseDelta: 100,
})
);
});
test('diff against parent event', () => {
element.patchRange = createPatchRange();
const diff: DiffInfo = {
...createDiff(),
content: [
{
a: ['foo', 'bar'],
b: ['baz', 'foo'],
},
],
};
element.reportDiff(diff);
assert.isTrue(reportStub.calledOnce);
assert.equal(reportStub.lastCall.args[0], 'diff-against-parent');
assert.isUndefined(reportStub.lastCall.args[1]);
});
});
suite('createCheckEl method', () => {
test('start_line:12', () => {
const result: RunResult = {
...createRunResult(),
codePointers: [{path: 'a', range: {start_line: 12} as CommentRange}],
};
const el = element.createCheckEl(result);
assert.equal(el.getAttribute('slot'), 'right-12');
assert.equal(el.getAttribute('diff-side'), 'right');
assert.equal(el.getAttribute('line-num'), '12');
assert.equal(el.getAttribute('range'), null);
assert.equal(el.result, result);
});
test('start_line:13 end_line:14 without char positions', () => {
const result: RunResult = {
...createRunResult(),
codePointers: [
{path: 'a', range: {start_line: 13, end_line: 14} as CommentRange},
],
};
const el = element.createCheckEl(result);
assert.equal(el.getAttribute('slot'), 'right-14');
assert.equal(el.getAttribute('diff-side'), 'right');
assert.equal(el.getAttribute('line-num'), '14');
assert.equal(el.getAttribute('range'), null);
assert.equal(el.result, result);
});
test('start_line:13 end_line:14 with char positions', () => {
const result: RunResult = {
...createRunResult(),
codePointers: [
{
path: 'a',
range: {
start_line: 13,
end_line: 14,
start_character: 5,
end_character: 7,
},
},
],
};
const el = element.createCheckEl(result);
assert.equal(el.getAttribute('slot'), 'right-14');
assert.equal(el.getAttribute('diff-side'), 'right');
assert.equal(el.getAttribute('line-num'), '14');
assert.equal(
el.getAttribute('range'),
'{"start_line":13,' +
'"end_line":14,' +
'"start_character":5,' +
'"end_character":7}'
);
assert.equal(el.result, result);
});
test('empty range', () => {
const result: RunResult = {
...createRunResult(),
codePointers: [{path: 'a', range: {} as CommentRange}],
};
const el = element.createCheckEl(result);
assert.equal(el.getAttribute('slot'), 'right-FILE');
assert.equal(el.getAttribute('diff-side'), 'right');
assert.equal(el.getAttribute('line-num'), 'FILE');
assert.equal(el.getAttribute('range'), null);
assert.equal(el.result, result);
});
});
suite('create-comment', () => {
setup(async () => {
account = createAccountDetailWithId(1);
element.disconnectedCallback();
element.connectedCallback();
await element.updateComplete;
});
test('creates comments if they do not exist yet', async () => {
element.patchRange = createPatchRange();
element.dispatchEvent(
new CustomEvent('create-comment', {
detail: {
lineNum: 3,
side: Side.LEFT,
path: '/p',
},
})
);
assertIsDefined(element.diffElement);
let threads =
element.diffElement.querySelectorAll<GrCommentThread>(
'gr-comment-thread'
);
assert.equal(threads.length, 1);
assert.equal(threads[0].thread?.commentSide, CommentSide.PARENT);
assert.equal(threads[0].getAttribute('diff-side'), Side.LEFT);
assert.equal(threads[0].thread?.range, undefined);
assert.equal(threads[0].thread?.patchNum, 1 as RevisionPatchSetNum);
// Try to fetch a thread with a different range.
const range = {
start_line: 1,
start_character: 1,
end_line: 1,
end_character: 3,
};
element.patchRange = createPatchRange();
element.dispatchEvent(
new CustomEvent('create-comment', {
detail: {
lineNum: 1,
side: Side.LEFT,
path: '/p',
range,
},
})
);
assertIsDefined(element.diffElement);
threads =
element.diffElement.querySelectorAll<GrCommentThread>(
'gr-comment-thread'
);
assert.equal(threads.length, 2);
assert.equal(threads[0].thread?.commentSide, CommentSide.PARENT);
assert.equal(threads[0].getAttribute('diff-side'), Side.LEFT);
assert.equal(threads[1].thread?.range, range);
assert.equal(threads[1].thread?.patchNum, 1 as RevisionPatchSetNum);
});
test('should not be on parent if on the right', async () => {
element.patchRange = createPatchRange(2, 3);
// Need to recompute threads.
await element.updateComplete;
element.dispatchEvent(
new CustomEvent('create-comment', {
detail: {
side: Side.RIGHT,
},
})
);
assertIsDefined(element.diffElement);
const threads =
element.diffElement.querySelectorAll<GrCommentThread>(
'gr-comment-thread'
);
assert.equal(threads.length, 1);
const threadEl = threads[0];
assert.equal(threadEl.thread?.commentSide, CommentSide.REVISION);
assert.equal(threadEl.getAttribute('diff-side'), Side.RIGHT);
});
test('should be on parent if right and base is PARENT', () => {
element.patchRange = createPatchRange();
element.dispatchEvent(
new CustomEvent('create-comment', {
detail: {
side: Side.LEFT,
},
})
);
assertIsDefined(element.diffElement);
const threads =
element.diffElement.querySelectorAll<GrCommentThread>(
'gr-comment-thread'
);
const threadEl = threads[0];
assert.equal(threadEl.thread?.commentSide, CommentSide.PARENT);
assert.equal(threadEl.getAttribute('diff-side'), Side.LEFT);
});
test('should be on parent if right and base negative', () => {
element.patchRange = createPatchRange(-2, 3);
element.dispatchEvent(
new CustomEvent('create-comment', {
detail: {
side: Side.LEFT,
},
})
);
assertIsDefined(element.diffElement);
const threads =
element.diffElement.querySelectorAll<GrCommentThread>(
'gr-comment-thread'
);
const threadEl = threads[0];
assert.equal(threadEl.thread?.commentSide, CommentSide.PARENT);
assert.equal(threadEl.getAttribute('diff-side'), Side.LEFT);
});
test('should not be on parent otherwise', () => {
element.patchRange = createPatchRange(2, 3);
element.dispatchEvent(
new CustomEvent('create-comment', {
detail: {
side: Side.LEFT,
},
})
);
assertIsDefined(element.diffElement);
const threads =
element.diffElement.querySelectorAll<GrCommentThread>(
'gr-comment-thread'
);
const threadEl = threads[0];
assert.equal(threadEl.thread?.commentSide, CommentSide.REVISION);
assert.equal(threadEl.getAttribute('diff-side'), Side.LEFT);
});
test(
'thread should use old file path if first created ' +
'on patch set (left) before renaming',
async () => {
element.patchRange = createPatchRange(2, 3);
element.file = {basePath: 'file_renamed.txt', path: element.path ?? ''};
await element.updateComplete;
element.dispatchEvent(
new CustomEvent('create-comment', {
detail: {
side: Side.LEFT,
path: '/p',
},
})
);
assertIsDefined(element.diffElement);
const threads =
element.diffElement.querySelectorAll<GrCommentThread>(
'gr-comment-thread'
);
assert.equal(threads.length, 1);
assert.equal(threads[0].getAttribute('diff-side'), Side.LEFT);
assert.equal(threads[0].thread?.path, element.file.basePath);
}
);
test(
'thread should use new file path if first created ' +
'on patch set (right) after renaming',
async () => {
element.patchRange = createPatchRange(2, 3);
element.file = {basePath: 'file_renamed.txt', path: element.path ?? ''};
await element.updateComplete;
element.dispatchEvent(
new CustomEvent('create-comment', {
detail: {
side: Side.RIGHT,
path: '/p',
},
})
);
assertIsDefined(element.diffElement);
const threads =
element.diffElement.querySelectorAll<GrCommentThread>(
'gr-comment-thread'
);
assert.equal(threads.length, 1);
assert.equal(threads[0].getAttribute('diff-side'), Side.RIGHT);
assert.equal(threads[0].thread?.path, element.file.path);
}
);
test('multiple threads created on the same range', async () => {
element.patchRange = createPatchRange(2, 3);
element.file = {basePath: 'file_renamed.txt', path: element.path ?? ''};
await element.updateComplete;
const comment = {
...createComment(),
range: {
start_line: 1,
start_character: 1,
end_line: 2,
end_character: 2,
},
patch_set: 3 as RevisionPatchSetNum,
};
const thread = createCommentThread([comment]);
element.threads = [thread];
await element.updateComplete;
assertIsDefined(element.diffElement);
let threads =
element.diffElement.querySelectorAll<GrCommentThread>(
'gr-comment-thread'
);
assert.equal(threads.length, 1);
element.threads = [...element.threads, thread];
await element.updateComplete;
assertIsDefined(element.diffElement);
threads =
element.diffElement.querySelectorAll<GrCommentThread>(
'gr-comment-thread'
);
// Threads have same rootId so element is reused
assert.equal(threads.length, 1);
const newThread = {...thread};
newThread.rootId = 'differentRootId' as UrlEncodedCommentId;
element.threads = [...element.threads, newThread];
await element.updateComplete;
threads =
element.diffElement.querySelectorAll<GrCommentThread>(
'gr-comment-thread'
);
// New thread has a different rootId
assert.equal(threads.length, 2);
});
test('unsaved thread changes to draft', async () => {
element.patchRange = createPatchRange(2, 3);
element.file = {basePath: 'file_renamed.txt', path: element.path ?? ''};
element.threads = [];
await element.updateComplete;
element.dispatchEvent(
new CustomEvent('create-comment', {
detail: {
side: Side.RIGHT,
path: element.path,
lineNum: 13,
},
})
);
await element.updateComplete;
assert.equal(element.getThreadEls().length, 1);
const threadEl = element.getThreadEls()[0];
assert.equal(threadEl.thread?.line, 13);
assert.isDefined(threadEl.unsavedComment);
assert.equal(threadEl.thread?.comments.length, 0);
const draftThread = createCommentThread([
{
path: element.path,
patch_set: 3 as RevisionPatchSetNum,
line: 13,
__draft: true,
},
]);
element.threads = [draftThread];
await element.updateComplete;
// We expect that no additional thread element was created.
assert.equal(element.getThreadEls().length, 1);
// In fact the thread element must still be the same.
assert.equal(element.getThreadEls()[0], threadEl);
// But it must have been updated from unsaved to draft:
assert.isUndefined(threadEl.unsavedComment);
assert.equal(threadEl.thread?.comments.length, 1);
});
test(
'thread should use new file path if first created ' +
'on patch set (left) but is base',
async () => {
element.patchRange = createPatchRange();
element.file = {basePath: 'file_renamed.txt', path: element.path ?? ''};
await element.updateComplete;
element.dispatchEvent(
new CustomEvent('create-comment', {
detail: {
side: Side.LEFT,
path: '/p',
},
})
);
assertIsDefined(element.diffElement);
const threads =
element.diffElement.querySelectorAll<GrCommentThread>(
'gr-comment-thread'
);
assert.equal(threads.length, 1);
assert.equal(threads[0].getAttribute('diff-side'), Side.LEFT);
assert.equal(threads[0].thread?.path, element.file.path);
}
);
test('cannot create thread on an edit', () => {
const alertSpy = sinon.spy();
element.addEventListener('show-alert', alertSpy);
const diffSide = Side.RIGHT;
element.patchRange = {
basePatchNum: 3 as BasePatchSetNum,
patchNum: EDIT,
};
element.dispatchEvent(
new CustomEvent('create-comment', {
detail: {
side: diffSide,
path: '/p',
},
})
);
assertIsDefined(element.diffElement);
const threads =
element.diffElement.querySelectorAll<GrCommentThread>(
'gr-comment-thread'
);
assert.equal(threads.length, 0);
assert.isTrue(alertSpy.called);
});
test('cannot create thread on an edit base', () => {
const alertSpy = sinon.spy();
element.addEventListener('show-alert', alertSpy);
const diffSide = Side.LEFT;
element.patchRange = {
basePatchNum: PARENT,
patchNum: EDIT,
};
element.dispatchEvent(
new CustomEvent('create-comment', {
detail: {
side: diffSide,
path: '/p',
},
})
);
assertIsDefined(element.diffElement);
const threads =
element.diffElement.querySelectorAll<GrCommentThread>(
'gr-comment-thread'
);
assert.equal(threads.length, 0);
assert.isTrue(alertSpy.called);
});
});
test('filterThreadElsForLocation with no threads', () => {
const line = {beforeNumber: 3, afterNumber: 5};
const threads: GrCommentThread[] = [];
assert.deepEqual(
element.filterThreadElsForLocation(threads, line, Side.LEFT),
[]
);
assert.deepEqual(
element.filterThreadElsForLocation(threads, line, Side.RIGHT),
[]
);
});
test('filterThreadElsForLocation for line comments', () => {
const line = {beforeNumber: 3, afterNumber: 5};
const l3 = document.createElement('gr-comment-thread');
l3.setAttribute('line-num', '3');
l3.setAttribute('diff-side', Side.LEFT);
const l5 = document.createElement('gr-comment-thread');
l5.setAttribute('line-num', '5');
l5.setAttribute('diff-side', Side.LEFT);
const r3 = document.createElement('gr-comment-thread');
r3.setAttribute('line-num', '3');
r3.setAttribute('diff-side', Side.RIGHT);
const r5 = document.createElement('gr-comment-thread');
r5.setAttribute('line-num', '5');
r5.setAttribute('diff-side', Side.RIGHT);
const threadEls: GrCommentThread[] = [l3, l5, r3, r5];
assert.deepEqual(
element.filterThreadElsForLocation(threadEls, line, Side.LEFT),
[l3]
);
assert.deepEqual(
element.filterThreadElsForLocation(threadEls, line, Side.RIGHT),
[r5]
);
});
test('filterThreadElsForLocation for file comments', () => {
const line: LineInfo = {beforeNumber: 'FILE', afterNumber: 'FILE'};
const l = document.createElement('gr-comment-thread');
l.setAttribute('diff-side', Side.LEFT);
l.setAttribute('line-num', 'FILE');
const r = document.createElement('gr-comment-thread');
r.setAttribute('diff-side', Side.RIGHT);
r.setAttribute('line-num', 'FILE');
const threadEls: GrCommentThread[] = [l, r];
assert.deepEqual(
element.filterThreadElsForLocation(threadEls, line, Side.LEFT),
[l]
);
assert.deepEqual(
element.filterThreadElsForLocation(threadEls, line, Side.RIGHT),
[r]
);
});
suite('syntax layer with syntax_highlighting on', async () => {
setup(async () => {
const prefs = {
...createDefaultDiffPrefs(),
line_length: 10,
show_tabs: true,
tab_size: 4,
context: -1,
syntax_highlighting: true,
};
element.patchRange = createPatchRange();
element.prefs = prefs;
element.changeNum = 123 as NumericChangeId;
element.change = createChange();
element.path = 'some/path';
});
test('gr-diff-host provides syntax highlighting layer', async () => {
getDiffRestApiStub.returns(Promise.resolve(createDiff()));
await element.updateComplete;
assertIsDefined(element.diffElement);
assertIsDefined(element.diffElement.layers);
assert.equal(element.diffElement.layers[1], element.syntaxLayer);
});
test('rendering normal-sized diff does not disable syntax', async () => {
element.diff = createDiff();
getDiffRestApiStub.returns(Promise.resolve(element.diff));
await element.updateComplete;
assert.isTrue(element.syntaxLayer.enabled);
});
test('rendering large diff disables syntax', async () => {
// Before it renders, set the first diff line to 500 '*' characters.
getDiffRestApiStub.returns(
Promise.resolve({
...createDiff(),
content: [
{
a: [new Array(501).join('*')],
},
],
})
);
element.reload();
await element.waitForReloadToRender();
assert.isFalse(element.syntaxLayer.enabled);
});
test('starts syntax layer processing on render event', async () => {
const stub = sinon
.stub(element.syntaxLayer, 'process')
.returns(Promise.resolve());
getDiffRestApiStub.returns(Promise.resolve(createDiff()));
await element.reload();
element.dispatchEvent(
new CustomEvent('render', {bubbles: true, composed: true})
);
assert.isTrue(stub.called);
});
});
suite('syntax layer with syntax_highlighting off', () => {
setup(async () => {
const prefs = {
...createDefaultDiffPrefs(),
line_length: 10,
show_tabs: true,
tab_size: 4,
context: -1,
syntax_highlighting: false,
};
element.patchRange = createPatchRange();
element.change = createChange();
element.prefs = prefs;
});
test('gr-diff-host provides syntax highlighting layer', async () => {
await element.waitForReloadToRender();
assertIsDefined(element.diffElement);
assertIsDefined(element.diffElement.layers);
assert.equal(element.diffElement.layers[1], element.syntaxLayer);
});
test('syntax layer should be disabled', async () => {
await element.waitForReloadToRender();
assert.isFalse(element.syntaxLayer.enabled);
});
test('still disabled for large diff', async () => {
getDiffRestApiStub.callsFake(() =>
Promise.resolve({
...createDiff(),
content: [
{
a: [new Array(501).join('*')],
},
],
})
);
await element.waitForReloadToRender();
assert.isFalse(element.syntaxLayer.enabled);
});
});
suite('coverage layer', () => {
let notifyStub: SinonStub;
let coverageProviderStub: SinonStub;
let getCoverageAnnotationApisStub: SinonStub;
const exampleRanges = [
{
type: CoverageType.COVERED,
side: Side.RIGHT,
code_range: {
start_line: 1,
end_line: 2,
},
},
{
type: CoverageType.NOT_COVERED,
side: Side.RIGHT,
code_range: {
start_line: 3,
end_line: 4,
},
},
];
setup(async () => {
notifyStub = sinon.stub();
coverageProviderStub = sinon
.stub()
.returns(Promise.resolve(exampleRanges));
element = basicFixture.instantiate();
element.changeNum = 123 as NumericChangeId;
element.change = createChange();
element.path = 'some/path';
const prefs = {
...createDefaultDiffPrefs(),
line_length: 10,
show_tabs: true,
tab_size: 4,
context: -1,
};
element.patchRange = createPatchRange();
element.prefs = prefs;
getDiffRestApiStub.returns(
Promise.resolve({
...createDiff(),
content: [{a: ['foo']}],
})
);
getCoverageAnnotationApisStub = sinon
.stub(element.jsAPI, 'getCoverageAnnotationApis')
.returns(
Promise.resolve([
{
notify: notifyStub,
getCoverageProvider() {
return coverageProviderStub;
},
} as unknown as GrAnnotationActionsInterface,
])
);
});
test('getCoverageAnnotationApis should be called', async () => {
await element.waitForReloadToRender();
assert.isTrue(getCoverageAnnotationApisStub.calledOnce);
});
test('coverageRangeChanged should be called', async () => {
await element.waitForReloadToRender();
assert.equal(notifyStub.callCount, 2);
assert.isTrue(
notifyStub.calledWithExactly('some/path', 1, 2, Side.RIGHT)
);
assert.isTrue(
notifyStub.calledWithExactly('some/path', 3, 4, Side.RIGHT)
);
});
test('provider is called with appropriate params', async () => {
element.patchRange = createPatchRange(1, 3);
await element.waitForReloadToRender();
assert.isTrue(
coverageProviderStub.calledWithExactly(
123,
'some/path',
1,
3,
element.change
)
);
});
test('provider is called with appropriate params - special patchset values', async () => {
element.patchRange = createPatchRange();
await element.waitForReloadToRender();
assert.isTrue(
coverageProviderStub.calledWithExactly(
123,
'some/path',
undefined,
1,
element.change
)
);
});
});
suite('trailing newlines', () => {
setup(() => {});
suite('lastChunkForSide', () => {
test('deltas', () => {
const diff: DiffInfo = {
...createDiff(),
content: [
{a: ['foo', 'bar'], b: ['baz']},
{ab: ['foo', 'bar', 'baz']},
{b: ['foo']},
],
};
assert.equal(element.lastChunkForSide(diff, false), diff.content[2]);
assert.equal(element.lastChunkForSide(diff, true), diff.content[1]);
diff.content.push({a: ['foo'], b: ['bar']});
assert.equal(element.lastChunkForSide(diff, false), diff.content[3]);
assert.equal(element.lastChunkForSide(diff, true), diff.content[3]);
});
test('addition with a undefined', () => {
const diff: DiffInfo = {
...createDiff(),
content: [{b: ['foo', 'bar', 'baz']}],
};
assert.equal(element.lastChunkForSide(diff, false), diff.content[0]);
assert.isNull(element.lastChunkForSide(diff, true));
});
test('addition with a empty', () => {
const diff: DiffInfo = {
...createDiff(),
content: [{a: [], b: ['foo', 'bar', 'baz']}],
};
assert.equal(element.lastChunkForSide(diff, false), diff.content[0]);
assert.isNull(element.lastChunkForSide(diff, true));
});
test('deletion with b undefined', () => {
const diff: DiffInfo = {
...createDiff(),
content: [{a: ['foo', 'bar', 'baz']}],
};
assert.isNull(element.lastChunkForSide(diff, false));
assert.equal(element.lastChunkForSide(diff, true), diff.content[0]);
});
test('deletion with b empty', () => {
const diff: DiffInfo = {
...createDiff(),
content: [{a: ['foo', 'bar', 'baz'], b: []}],
};
assert.isNull(element.lastChunkForSide(diff, false));
assert.equal(element.lastChunkForSide(diff, true), diff.content[0]);
});
test('empty', () => {
const diff: DiffInfo = {...createDiff(), content: []};
assert.isNull(element.lastChunkForSide(diff, false));
assert.isNull(element.lastChunkForSide(diff, true));
});
});
suite('hasTrailingNewlines', () => {
test('shared no trailing', () => {
const diff = undefined;
sinon.stub(element, 'lastChunkForSide').returns({ab: ['foo', 'bar']});
assert.isFalse(element.hasTrailingNewlines(diff, false));
assert.isFalse(element.hasTrailingNewlines(diff, true));
});
test('delta trailing in right', () => {
const diff = undefined;
sinon
.stub(element, 'lastChunkForSide')
.returns({a: ['foo', 'bar'], b: ['baz', '']});
assert.isTrue(element.hasTrailingNewlines(diff, false));
assert.isFalse(element.hasTrailingNewlines(diff, true));
});
test('addition', () => {
const diff: DiffInfo | undefined = undefined;
sinon
.stub(element, 'lastChunkForSide')
.callsFake((_: DiffInfo | undefined, leftSide: boolean) => {
if (leftSide) {
return null;
}
return {b: ['foo', '']};
});
assert.isTrue(element.hasTrailingNewlines(diff, false));
assert.isNull(element.hasTrailingNewlines(diff, true));
});
test('deletion', () => {
const diff: DiffInfo | undefined = undefined;
sinon
.stub(element, 'lastChunkForSide')
.callsFake((_: DiffInfo | undefined, leftSide: boolean) => {
if (!leftSide) {
return null;
}
return {a: ['foo']};
});
assert.isNull(element.hasTrailingNewlines(diff, false));
assert.isFalse(element.hasTrailingNewlines(diff, true));
});
});
});
});