9d9a8b0131
If a comment was created with Side=PARENT, then we show this ported comment if Base is part of the patch range, always on the left side of the diff. Change-Id: I4aed6e126d4dfadf7a43c143bbbdd47d1d416ad5
960 lines
32 KiB
JavaScript
960 lines
32 KiB
JavaScript
/**
|
|
* @license
|
|
* Copyright (C) 2017 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-comment-api.js';
|
|
import {ChangeComments} from './gr-comment-api.js';
|
|
import {isInRevisionOfPatchRange, isInBaseOfPatchRange, isDraftThread, isUnresolved, createCommentThreads} from '../../../utils/comment-util.js';
|
|
import {createDraft, createComment, createChangeComments, createCommentThread} from '../../../test/test-data-generators.js';
|
|
import {CommentSide, Side} from '../../../constants/constants.js';
|
|
|
|
const basicFixture = fixtureFromElement('gr-comment-api');
|
|
|
|
suite('gr-comment-api tests', () => {
|
|
const PARENT = 'PARENT';
|
|
|
|
let element;
|
|
|
|
setup(() => {
|
|
element = basicFixture.instantiate();
|
|
});
|
|
|
|
test('loads logged-out', () => {
|
|
const changeNum = 1234;
|
|
|
|
sinon.stub(element.restApiService, 'getLoggedIn')
|
|
.returns(Promise.resolve(false));
|
|
sinon.stub(element.restApiService, 'getDiffComments')
|
|
.returns(Promise.resolve({
|
|
'foo.c': [{id: '123', message: 'foo bar', in_reply_to: '321'}],
|
|
}));
|
|
sinon.stub(element.restApiService, 'getDiffRobotComments')
|
|
.returns(Promise.resolve({'foo.c': [{id: '321', message: 'done'}]}));
|
|
sinon.stub(element.restApiService, 'getDiffDrafts')
|
|
.returns(Promise.resolve({}));
|
|
|
|
return element.loadAll(changeNum).then(() => {
|
|
assert.isTrue(element.restApiService.getDiffComments.calledWithExactly(
|
|
changeNum));
|
|
assert.isTrue(
|
|
element.restApiService.getDiffRobotComments.calledWithExactly(
|
|
changeNum));
|
|
assert.isTrue(element.restApiService.getDiffDrafts.calledWithExactly(
|
|
changeNum));
|
|
assert.isOk(element._changeComments._comments);
|
|
assert.isOk(element._changeComments._robotComments);
|
|
assert.deepEqual(element._changeComments._drafts, {});
|
|
});
|
|
});
|
|
|
|
test('loads logged-in', () => {
|
|
const changeNum = 1234;
|
|
|
|
sinon.stub(element.restApiService, 'getLoggedIn')
|
|
.returns(Promise.resolve(true));
|
|
sinon.stub(element.restApiService, 'getDiffComments')
|
|
.returns(Promise.resolve({
|
|
'foo.c': [{id: '123', message: 'foo bar', in_reply_to: '321'}],
|
|
}));
|
|
sinon.stub(element.restApiService, 'getDiffRobotComments')
|
|
.returns(Promise.resolve({'foo.c': [{id: '321', message: 'done'}]}));
|
|
sinon.stub(element.restApiService, 'getDiffDrafts')
|
|
.returns(Promise.resolve({'foo.c': [{id: '555', message: 'ack'}]}));
|
|
|
|
return element.loadAll(changeNum).then(() => {
|
|
assert.isTrue(element.restApiService.getDiffComments.calledWithExactly(
|
|
changeNum));
|
|
assert.isTrue(
|
|
element.restApiService.getDiffRobotComments.calledWithExactly(
|
|
changeNum));
|
|
assert.isTrue(element.restApiService.getDiffDrafts.calledWithExactly(
|
|
changeNum));
|
|
assert.isOk(element._changeComments._comments);
|
|
assert.isOk(element._changeComments._robotComments);
|
|
assert.notDeepEqual(element._changeComments._drafts, {});
|
|
});
|
|
});
|
|
|
|
suite('reloadDrafts', () => {
|
|
let commentStub;
|
|
let robotCommentStub;
|
|
let draftStub;
|
|
setup(() => {
|
|
commentStub = sinon.stub(element.restApiService, 'getDiffComments')
|
|
.returns(Promise.resolve({}));
|
|
robotCommentStub = sinon.stub(element.restApiService,
|
|
'getDiffRobotComments').returns(Promise.resolve({}));
|
|
draftStub = sinon.stub(element.restApiService, 'getDiffDrafts')
|
|
.returns(Promise.resolve({}));
|
|
});
|
|
|
|
test('without loadAll first', done => {
|
|
assert.isNotOk(element._changeComments);
|
|
sinon.spy(element, 'loadAll');
|
|
element.reloadDrafts().then(() => {
|
|
assert.isTrue(element.loadAll.called);
|
|
assert.isOk(element._changeComments);
|
|
assert.equal(commentStub.callCount, 1);
|
|
assert.equal(robotCommentStub.callCount, 1);
|
|
assert.equal(draftStub.callCount, 1);
|
|
done();
|
|
});
|
|
});
|
|
|
|
test('with loadAll first', done => {
|
|
assert.isNotOk(element._changeComments);
|
|
element.loadAll()
|
|
.then(() => {
|
|
assert.isOk(element._changeComments);
|
|
assert.equal(commentStub.callCount, 1);
|
|
assert.equal(robotCommentStub.callCount, 1);
|
|
assert.equal(draftStub.callCount, 1);
|
|
return element.reloadDrafts();
|
|
})
|
|
.then(() => {
|
|
assert.isOk(element._changeComments);
|
|
assert.equal(commentStub.callCount, 1);
|
|
assert.equal(robotCommentStub.callCount, 1);
|
|
assert.equal(draftStub.callCount, 2);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
suite('_changeComment methods', () => {
|
|
setup(done => {
|
|
const changeNum = 1234;
|
|
stub('gr-rest-api-interface', {
|
|
getDiffComments() { return Promise.resolve({}); },
|
|
getDiffRobotComments() { return Promise.resolve({}); },
|
|
getDiffDrafts() { return Promise.resolve({}); },
|
|
});
|
|
element.loadAll(changeNum).then(() => {
|
|
done();
|
|
});
|
|
});
|
|
|
|
suite('ported comments', () => {
|
|
let portedComments;
|
|
let changeComments;
|
|
const comment1 = {
|
|
...createComment(),
|
|
unresolved: true,
|
|
id: '1',
|
|
line: 136,
|
|
patch_set: 2,
|
|
range: {
|
|
start_line: 1,
|
|
start_character: 1,
|
|
end_line: 1,
|
|
end_character: 1,
|
|
},
|
|
};
|
|
|
|
const comment2 = {
|
|
...createComment(),
|
|
patch_set: 2,
|
|
id: '2',
|
|
line: 5,
|
|
};
|
|
|
|
const comment3 = {
|
|
...createComment(),
|
|
side: CommentSide.PARENT,
|
|
line: 10,
|
|
unresolved: true,
|
|
};
|
|
|
|
const comment4 = {
|
|
...comment3,
|
|
parent: -2,
|
|
};
|
|
|
|
const draft1 = {
|
|
...createDraft(),
|
|
id: 'db977012_e1f13828',
|
|
line: 4,
|
|
patch_set: 2,
|
|
};
|
|
const draft2 = {
|
|
...createDraft(),
|
|
id: '503008e2_0ab203ee',
|
|
line: 11,
|
|
unresolved: true,
|
|
// slightly larger timestamp so it's sorted higher
|
|
updated: '2018-02-13 22:49:48.018000001',
|
|
patch_set: 2,
|
|
};
|
|
|
|
setup(() => {
|
|
portedComments = {
|
|
'karma.conf.js': [{
|
|
...comment1,
|
|
patch_set: 4,
|
|
range: {
|
|
start_line: 136,
|
|
start_character: 16,
|
|
end_line: 136,
|
|
end_character: 29,
|
|
},
|
|
}],
|
|
};
|
|
|
|
changeComments = new ChangeComments(
|
|
{/* comments */
|
|
'karma.conf.js': [
|
|
// resolved comment that will not be ported over
|
|
comment2,
|
|
// original comment that will be ported over to patchset 4
|
|
comment1,
|
|
],
|
|
},
|
|
{}/* robot comments */,
|
|
{}/* drafts */,
|
|
portedComments,
|
|
{}/* ported drafts */
|
|
);
|
|
});
|
|
|
|
test('threads containing ported comment are returned', () => {
|
|
assert.equal(changeComments.getAllThreadsForChange().length,
|
|
2);
|
|
|
|
const portedThreads = changeComments._getPortedCommentThreads(
|
|
{path: 'karma.conf.js'}, {patchNum: 4, basePatchNum: 'PARENT'});
|
|
|
|
assert.equal(portedThreads.length, 1);
|
|
// check range of thread is from the ported comment and not the original
|
|
assert.deepEqual(portedThreads[0].range, {
|
|
start_line: 136,
|
|
start_character: 16,
|
|
end_line: 136,
|
|
end_character: 29,
|
|
});
|
|
|
|
// thread ported over if comparing patchset 1 vs patchset 4
|
|
assert.equal(changeComments._getPortedCommentThreads(
|
|
{path: 'karma.conf.js'}, {patchNum: 4, basePatchNum: 1}
|
|
).length, 1);
|
|
|
|
// verify ported thread is not returned if original thread will be
|
|
// shown
|
|
// original thread attached to right side
|
|
assert.equal(changeComments._getPortedCommentThreads(
|
|
{path: 'karma.conf.js'}, {patchNum: 2, basePatchNum: 'PARENT'}
|
|
).length, 0);
|
|
assert.equal(changeComments._getPortedCommentThreads(
|
|
{path: 'karma.conf.js'}, {patchNum: 2, basePatchNum: 1}
|
|
).length, 0);
|
|
|
|
// original thread attached to left side
|
|
assert.equal(changeComments._getPortedCommentThreads(
|
|
{path: 'karma.conf.js'}, {patchNum: 3, basePatchNum: 2}
|
|
).length, 0);
|
|
});
|
|
|
|
test('threads without any ported comment are filtered out', () => {
|
|
changeComments = new ChangeComments(
|
|
{/* comments */
|
|
// comment that is not ported over
|
|
'karma.conf.js': [comment2],
|
|
},
|
|
{}/* robot comments */,
|
|
{/* drafts */
|
|
'karma.conf.js': [draft2],
|
|
},
|
|
// comment1 that is ported over but does not have any thread
|
|
// that has a comment that matches it
|
|
portedComments,
|
|
{}/* ported drafts */
|
|
);
|
|
|
|
assert.equal(createCommentThreads(changeComments
|
|
.getAllCommentsForPath('karma.conf.js')).length, 1);
|
|
assert.equal(changeComments._getPortedCommentThreads(
|
|
{path: 'karma.conf.js'}, {patchNum: 4, basePatchNum: 'PARENT'}
|
|
).length, 0);
|
|
});
|
|
|
|
test('comments with side=PARENT are ported over', () => {
|
|
changeComments = new ChangeComments(
|
|
{/* comments */
|
|
// comment left on Base
|
|
'karma.conf.js': [comment3],
|
|
},
|
|
{}/* robot comments */,
|
|
{/* drafts */
|
|
'karma.conf.js': [draft2],
|
|
},
|
|
{/* ported comments */
|
|
'karma.conf.js': [{
|
|
...comment3,
|
|
line: 31,
|
|
patch_set: 4,
|
|
}],
|
|
},
|
|
{}/* ported drafts */
|
|
);
|
|
|
|
const portedThreads = changeComments._getPortedCommentThreads(
|
|
{path: 'karma.conf.js'}, {patchNum: 4, basePatchNum: 'PARENT'});
|
|
assert.equal(portedThreads.length, 1);
|
|
assert.equal(portedThreads[0].line, 31);
|
|
assert.equal(portedThreads[0].diffSide, Side.LEFT);
|
|
|
|
assert.equal(changeComments._getPortedCommentThreads(
|
|
{path: 'karma.conf.js'}, {patchNum: 4, basePatchNum: -2}
|
|
).length, 0);
|
|
|
|
assert.equal(changeComments._getPortedCommentThreads(
|
|
{path: 'karma.conf.js'}, {patchNum: 4, basePatchNum: 2}
|
|
).length, 0);
|
|
});
|
|
|
|
test('comments left on merge parent is not ported over', () => {
|
|
changeComments = new ChangeComments(
|
|
{/* comments */
|
|
// comment left on Base
|
|
'karma.conf.js': [comment4],
|
|
},
|
|
{}/* robot comments */,
|
|
{/* drafts */
|
|
'karma.conf.js': [draft2],
|
|
},
|
|
{/* ported comments */
|
|
'karma.conf.js': [{
|
|
...comment4,
|
|
line: 31,
|
|
patch_set: 4,
|
|
}],
|
|
},
|
|
{}/* ported drafts */
|
|
);
|
|
|
|
const portedThreads = changeComments._getPortedCommentThreads(
|
|
{path: 'karma.conf.js'}, {patchNum: 4, basePatchNum: 'PARENT'});
|
|
assert.equal(portedThreads.length, 0);
|
|
|
|
assert.equal(changeComments._getPortedCommentThreads(
|
|
{path: 'karma.conf.js'}, {patchNum: 4, basePatchNum: -2}
|
|
).length, 0);
|
|
|
|
assert.equal(changeComments._getPortedCommentThreads(
|
|
{path: 'karma.conf.js'}, {patchNum: 4, basePatchNum: 2}
|
|
).length, 0);
|
|
});
|
|
|
|
test('ported comments contribute to comment count', () => {
|
|
assert.equal(changeComments.computeCommentsString(
|
|
{basePatchNum: 'PARENT', patchNum: 2}, 'karma.conf.js',
|
|
{__path: 'karma.conf.js'}), '2 comments (1 unresolved)');
|
|
|
|
// comment1 is ported over to patchset 4
|
|
assert.equal(changeComments.computeCommentsString(
|
|
{basePatchNum: 'PARENT', patchNum: 4}, 'karma.conf.js',
|
|
{__path: 'karma.conf.js'}), '1 comment (1 unresolved)');
|
|
});
|
|
|
|
test('drafts are ported over', () => {
|
|
changeComments = new ChangeComments(
|
|
{}/* comments */,
|
|
{}/* robotComments */,
|
|
{/* drafts */
|
|
// draft1: resolved draft that will be ported over to ps 4
|
|
// draft2: unresolved draft that will be ported over to ps 4
|
|
'karma.conf.js': [draft1, draft2],
|
|
},
|
|
{}/* ported comments */,
|
|
{/* ported drafts */
|
|
'karma.conf.js': [
|
|
{
|
|
...draft1,
|
|
line: 5,
|
|
patch_set: 4,
|
|
},
|
|
{
|
|
...draft2,
|
|
line: 31,
|
|
patch_set: 4,
|
|
},
|
|
],
|
|
}
|
|
);
|
|
|
|
const portedThreads = changeComments._getPortedCommentThreads(
|
|
{path: 'karma.conf.js'}, {patchNum: 4, basePatchNum: 'PARENT'});
|
|
|
|
// resolved draft is ported over
|
|
assert.equal(portedThreads.length, 2);
|
|
assert.equal(portedThreads[0].line, 5);
|
|
assert.isTrue(isDraftThread(portedThreads[0]));
|
|
assert.isFalse(isUnresolved(portedThreads[0]));
|
|
|
|
// unresolved draft is ported over
|
|
assert.equal(portedThreads[1].line, 31);
|
|
assert.isTrue(isDraftThread(portedThreads[1]));
|
|
assert.isTrue(isUnresolved(portedThreads[1]));
|
|
|
|
assert.equal(createCommentThreads(
|
|
changeComments.getAllCommentsForPath('karma.conf.js'),
|
|
{patchNum: 4, basePatchNum: 'PARENT'}).length, 0);
|
|
});
|
|
});
|
|
|
|
test('_isInBaseOfPatchRange', () => {
|
|
const comment = {patch_set: 1};
|
|
const patchRange = {basePatchNum: 1, patchNum: 2};
|
|
assert.isTrue(isInBaseOfPatchRange(comment,
|
|
patchRange));
|
|
|
|
patchRange.basePatchNum = PARENT;
|
|
assert.isFalse(isInBaseOfPatchRange(comment,
|
|
patchRange));
|
|
|
|
comment.side = PARENT;
|
|
assert.isFalse(isInBaseOfPatchRange(comment,
|
|
patchRange));
|
|
|
|
comment.patch_set = 2;
|
|
assert.isTrue(isInBaseOfPatchRange(comment,
|
|
patchRange));
|
|
|
|
patchRange.basePatchNum = -2;
|
|
comment.side = PARENT;
|
|
comment.parent = 1;
|
|
assert.isFalse(isInBaseOfPatchRange(comment,
|
|
patchRange));
|
|
|
|
comment.parent = 2;
|
|
assert.isTrue(isInBaseOfPatchRange(comment,
|
|
patchRange));
|
|
});
|
|
|
|
test('isInRevisionOfPatchRange', () => {
|
|
const comment = {patch_set: 123};
|
|
const patchRange = {basePatchNum: 122, patchNum: 124};
|
|
assert.isFalse(isInRevisionOfPatchRange(
|
|
comment, patchRange));
|
|
|
|
patchRange.patchNum = 123;
|
|
assert.isTrue(isInRevisionOfPatchRange(
|
|
comment, patchRange));
|
|
|
|
comment.side = PARENT;
|
|
assert.isFalse(isInRevisionOfPatchRange(
|
|
comment, patchRange));
|
|
});
|
|
|
|
suite('comment ranges and paths', () => {
|
|
const commentObjs = {};
|
|
function makeTime(mins) {
|
|
return `2013-02-26 15:0${mins}:43.986000000`;
|
|
}
|
|
|
|
setup(() => {
|
|
commentObjs['01'] = {
|
|
...createComment(),
|
|
id: '01',
|
|
patch_set: 2,
|
|
side: PARENT,
|
|
line: 1,
|
|
updated: makeTime(1),
|
|
range: {
|
|
start_line: 1,
|
|
start_character: 2,
|
|
end_line: 2,
|
|
end_character: 2,
|
|
},
|
|
};
|
|
|
|
commentObjs['02'] = {
|
|
...createComment(),
|
|
id: '02',
|
|
in_reply_to: '04',
|
|
patch_set: 2,
|
|
unresolved: true,
|
|
line: 1,
|
|
updated: makeTime(3),
|
|
};
|
|
|
|
commentObjs['03'] = {
|
|
...createComment(),
|
|
id: '03',
|
|
patch_set: 2,
|
|
side: PARENT,
|
|
line: 2,
|
|
updated: makeTime(1),
|
|
};
|
|
|
|
commentObjs['04'] = {
|
|
...createComment(),
|
|
id: '04',
|
|
patch_set: 2,
|
|
line: 1,
|
|
updated: makeTime(1),
|
|
};
|
|
|
|
commentObjs['05'] = {
|
|
...createComment(),
|
|
id: '05',
|
|
patch_set: 2,
|
|
line: 2,
|
|
updated: makeTime(1),
|
|
};
|
|
|
|
commentObjs['06'] = {
|
|
...createComment(),
|
|
id: '06',
|
|
patch_set: 3,
|
|
line: 2,
|
|
updated: makeTime(1),
|
|
};
|
|
|
|
commentObjs['07'] = {
|
|
...createComment(),
|
|
id: '07',
|
|
patch_set: 2,
|
|
side: PARENT,
|
|
unresolved: false,
|
|
line: 1,
|
|
updated: makeTime(1),
|
|
};
|
|
|
|
commentObjs['08'] = {
|
|
...createComment(),
|
|
id: '08',
|
|
patch_set: 2,
|
|
side: PARENT,
|
|
unresolved: true,
|
|
in_reply_to: '07',
|
|
line: 1,
|
|
updated: makeTime(1),
|
|
};
|
|
|
|
commentObjs['09'] = {
|
|
...createComment(),
|
|
id: '09',
|
|
patch_set: 3,
|
|
line: 1,
|
|
updated: makeTime(1),
|
|
};
|
|
|
|
commentObjs['10'] = {
|
|
...createComment(),
|
|
id: '10',
|
|
patch_set: 5,
|
|
side: PARENT,
|
|
line: 1,
|
|
updated: makeTime(1),
|
|
};
|
|
|
|
commentObjs['11'] = {
|
|
...createComment(),
|
|
id: '11',
|
|
patch_set: 5,
|
|
line: 1,
|
|
updated: makeTime(1),
|
|
};
|
|
|
|
commentObjs['12'] = {
|
|
...createDraft(),
|
|
id: '12',
|
|
patch_set: 2,
|
|
side: PARENT,
|
|
line: 1,
|
|
updated: makeTime(3),
|
|
};
|
|
|
|
commentObjs['13'] = {
|
|
...createDraft(),
|
|
id: '13',
|
|
in_reply_to: '04',
|
|
patch_set: 2,
|
|
line: 1,
|
|
// Draft gets lower timestamp than published comment, because we
|
|
// want to test that the draft still gets sorted to the end.
|
|
updated: makeTime(2),
|
|
};
|
|
|
|
commentObjs['14'] = {
|
|
...createDraft(),
|
|
id: '14',
|
|
patch_set: 3,
|
|
line: 1,
|
|
path: 'file/two',
|
|
updated: makeTime(3),
|
|
};
|
|
|
|
const drafts = {
|
|
'file/one': [
|
|
commentObjs['12'],
|
|
commentObjs['13'],
|
|
],
|
|
'file/two': [
|
|
commentObjs['14'],
|
|
],
|
|
};
|
|
const robotComments = {
|
|
'file/one': [
|
|
commentObjs['01'], commentObjs['02'],
|
|
],
|
|
};
|
|
const comments = {
|
|
'file/one': [commentObjs['03'], commentObjs['04']],
|
|
'file/two': [commentObjs['05'], commentObjs['06']],
|
|
'file/three': [commentObjs['07'], commentObjs['08'],
|
|
commentObjs['09']],
|
|
'file/four': [commentObjs['10'], commentObjs['11']],
|
|
};
|
|
element._changeComments =
|
|
new ChangeComments(comments, robotComments, drafts, {}, {});
|
|
});
|
|
|
|
test('getPaths', () => {
|
|
const patchRange = {basePatchNum: 1, patchNum: 4};
|
|
let paths = element._changeComments.getPaths(patchRange);
|
|
assert.equal(Object.keys(paths).length, 0);
|
|
|
|
patchRange.basePatchNum = PARENT;
|
|
patchRange.patchNum = 3;
|
|
paths = element._changeComments.getPaths(patchRange);
|
|
assert.notProperty(paths, 'file/one');
|
|
assert.property(paths, 'file/two');
|
|
assert.property(paths, 'file/three');
|
|
assert.notProperty(paths, 'file/four');
|
|
|
|
patchRange.patchNum = 2;
|
|
paths = element._changeComments.getPaths(patchRange);
|
|
assert.property(paths, 'file/one');
|
|
assert.property(paths, 'file/two');
|
|
assert.property(paths, 'file/three');
|
|
assert.notProperty(paths, 'file/four');
|
|
|
|
paths = element._changeComments.getPaths();
|
|
assert.property(paths, 'file/one');
|
|
assert.property(paths, 'file/two');
|
|
assert.property(paths, 'file/three');
|
|
assert.property(paths, 'file/four');
|
|
});
|
|
|
|
test('getCommentsForPath', () => {
|
|
const patchRange = {basePatchNum: 1, patchNum: 3};
|
|
let path = 'file/one';
|
|
let comments = element._changeComments.getCommentsForPath(path,
|
|
patchRange);
|
|
assert.equal(comments.filter(c => isInBaseOfPatchRange(c, patchRange))
|
|
.length, 0);
|
|
assert.equal(comments.filter(c => isInRevisionOfPatchRange(c,
|
|
patchRange)).length, 0);
|
|
|
|
path = 'file/two';
|
|
comments = element._changeComments.getCommentsForPath(path,
|
|
patchRange);
|
|
assert.equal(comments.filter(c => isInBaseOfPatchRange(c, patchRange))
|
|
.length, 0);
|
|
assert.equal(comments.filter(c => isInRevisionOfPatchRange(c,
|
|
patchRange)).length, 2);
|
|
|
|
patchRange.basePatchNum = 2;
|
|
comments = element._changeComments.getCommentsForPath(path,
|
|
patchRange);
|
|
assert.equal(comments.filter(c => isInBaseOfPatchRange(c,
|
|
patchRange)).length, 1);
|
|
assert.equal(comments.filter(c => isInRevisionOfPatchRange(c,
|
|
patchRange)).length, 2);
|
|
|
|
patchRange.basePatchNum = PARENT;
|
|
path = 'file/three';
|
|
comments = element._changeComments.getCommentsForPath(path,
|
|
patchRange);
|
|
assert.equal(comments.filter(c => isInBaseOfPatchRange(c, patchRange))
|
|
.length, 0);
|
|
assert.equal(comments.filter(c => isInRevisionOfPatchRange(c,
|
|
patchRange)).length, 1);
|
|
});
|
|
|
|
test('getAllCommentsForPath', () => {
|
|
let path = 'file/one';
|
|
let comments = element._changeComments.getAllCommentsForPath(path);
|
|
assert.equal(comments.length, 4);
|
|
path = 'file/two';
|
|
comments = element._changeComments.getAllCommentsForPath(path, 2);
|
|
assert.equal(comments.length, 1);
|
|
const aCopyOfComments = element._changeComments
|
|
.getAllCommentsForPath(path, 2);
|
|
assert.deepEqual(comments, aCopyOfComments);
|
|
assert.notEqual(comments[0], aCopyOfComments[0]);
|
|
});
|
|
|
|
test('getAllDraftsForPath', () => {
|
|
const path = 'file/one';
|
|
const drafts = element._changeComments.getAllDraftsForPath(path);
|
|
assert.equal(drafts.length, 2);
|
|
const aCopyOfDrafts = element._changeComments
|
|
.getAllDraftsForPath(path);
|
|
assert.deepEqual(drafts, aCopyOfDrafts);
|
|
assert.notEqual(drafts[0], aCopyOfDrafts[0]);
|
|
});
|
|
|
|
test('computeUnresolvedNum', () => {
|
|
assert.equal(element._changeComments
|
|
.computeUnresolvedNum({
|
|
patchNum: 2,
|
|
path: 'file/one',
|
|
}), 0);
|
|
assert.equal(element._changeComments
|
|
.computeUnresolvedNum({
|
|
patchNum: 1,
|
|
path: 'file/one',
|
|
}), 0);
|
|
assert.equal(element._changeComments
|
|
.computeUnresolvedNum({
|
|
patchNum: 2,
|
|
path: 'file/three',
|
|
}), 1);
|
|
});
|
|
|
|
test('computeUnresolvedNum w/ non-linear thread', () => {
|
|
const comments = {
|
|
path: [{
|
|
id: '9c6ba3c6_28b7d467',
|
|
patch_set: 1,
|
|
updated: '2018-02-28 14:41:13.000000000',
|
|
unresolved: true,
|
|
}, {
|
|
id: '3df7b331_0bead405',
|
|
patch_set: 1,
|
|
in_reply_to: '1c346623_ab85d14a',
|
|
updated: '2018-02-28 23:07:55.000000000',
|
|
unresolved: false,
|
|
}, {
|
|
id: '6153dce6_69958d1e',
|
|
patch_set: 1,
|
|
in_reply_to: '9c6ba3c6_28b7d467',
|
|
updated: '2018-02-28 17:11:31.000000000',
|
|
unresolved: true,
|
|
}, {
|
|
id: '1c346623_ab85d14a',
|
|
patch_set: 1,
|
|
in_reply_to: '9c6ba3c6_28b7d467',
|
|
updated: '2018-02-28 23:01:39.000000000',
|
|
unresolved: false,
|
|
}],
|
|
};
|
|
element._changeComments = new ChangeComments(comments, {}, {}, 1234);
|
|
assert.equal(
|
|
element._changeComments.computeUnresolvedNum(1, 'path'), 0);
|
|
});
|
|
|
|
test('computeCommentsString', () => {
|
|
const changeComments = createChangeComments();
|
|
const parentTo1 = {
|
|
basePatchNum: 'PARENT',
|
|
patchNum: 1,
|
|
};
|
|
const parentTo2 = {
|
|
basePatchNum: 'PARENT',
|
|
patchNum: 2,
|
|
};
|
|
const _1To2 = {
|
|
basePatchNum: 1,
|
|
patchNum: 2,
|
|
};
|
|
|
|
assert.equal(
|
|
changeComments.computeCommentsString(parentTo1, '/COMMIT_MSG',
|
|
{__path: '/COMMIT_MSG'}), '2 comments (1 unresolved)');
|
|
assert.equal(
|
|
changeComments.computeCommentsString(parentTo1, '/COMMIT_MSG',
|
|
{__path: '/COMMIT_MSG', status: 'U'}, true),
|
|
'2 comments (1 unresolved)(no changes)');
|
|
assert.equal(
|
|
changeComments.computeCommentsString(_1To2, '/COMMIT_MSG',
|
|
{__path: '/COMMIT_MSG'}), '3 comments (1 unresolved)');
|
|
|
|
assert.equal(
|
|
changeComments.computeCommentsString(parentTo1, 'myfile.txt',
|
|
{__path: 'myfile.txt'}), '1 comment');
|
|
assert.equal(
|
|
changeComments.computeCommentsString(_1To2, 'myfile.txt',
|
|
{__path: 'myfile.txt'}), '3 comments');
|
|
|
|
assert.equal(
|
|
changeComments.computeCommentsString(parentTo1,
|
|
'file_added_in_rev2.txt',
|
|
{__path: 'file_added_in_rev2.txt'}), '');
|
|
assert.equal(
|
|
changeComments.computeCommentsString(_1To2,
|
|
'file_added_in_rev2.txt',
|
|
{__path: 'file_added_in_rev2.txt'}), '');
|
|
|
|
assert.equal(
|
|
changeComments.computeCommentsString(parentTo2, '/COMMIT_MSG',
|
|
{__path: '/COMMIT_MSG'}), '1 comment');
|
|
assert.equal(
|
|
changeComments.computeCommentsString(_1To2, '/COMMIT_MSG',
|
|
{__path: '/COMMIT_MSG'}), '3 comments (1 unresolved)');
|
|
|
|
assert.equal(
|
|
changeComments.computeCommentsString(parentTo2, 'myfile.txt',
|
|
{__path: 'myfile.txt'}), '2 comments');
|
|
assert.equal(
|
|
changeComments.computeCommentsString(_1To2, 'myfile.txt',
|
|
{__path: 'myfile.txt'}), '3 comments');
|
|
|
|
assert.equal(
|
|
changeComments.computeCommentsString(parentTo2,
|
|
'file_added_in_rev2.txt',
|
|
{__path: 'file_added_in_rev2.txt'}), '');
|
|
assert.equal(
|
|
changeComments.computeCommentsString(_1To2,
|
|
'file_added_in_rev2.txt',
|
|
{__path: 'file_added_in_rev2.txt'}), '');
|
|
assert.equal(
|
|
changeComments.computeCommentsString(parentTo2, 'unresolved.file',
|
|
{__path: 'unresolved.file'}), '2 comments (1 unresolved)');
|
|
assert.equal(
|
|
changeComments.computeCommentsString(_1To2, 'unresolved.file',
|
|
{__path: 'unresolved.file'}), '2 comments (1 unresolved)');
|
|
});
|
|
|
|
test('computeCommentThreadCount', () => {
|
|
assert.equal(element._changeComments
|
|
.computeCommentThreadCount({
|
|
patchNum: 2,
|
|
path: 'file/one',
|
|
}), 3);
|
|
assert.equal(element._changeComments
|
|
.computeCommentThreadCount({
|
|
patchNum: 1,
|
|
path: 'file/one',
|
|
}), 0);
|
|
assert.equal(element._changeComments
|
|
.computeCommentThreadCount({
|
|
patchNum: 2,
|
|
path: 'file/three',
|
|
}), 1);
|
|
});
|
|
|
|
test('computeDraftCount', () => {
|
|
assert.equal(element._changeComments
|
|
.computeDraftCount({
|
|
patchNum: 2,
|
|
path: 'file/one',
|
|
}), 2);
|
|
assert.equal(element._changeComments
|
|
.computeDraftCount({
|
|
patchNum: 1,
|
|
path: 'file/one',
|
|
}), 0);
|
|
assert.equal(element._changeComments
|
|
.computeDraftCount({
|
|
patchNum: 2,
|
|
path: 'file/three',
|
|
}), 0);
|
|
assert.equal(element._changeComments
|
|
.computeDraftCount(), 3);
|
|
});
|
|
|
|
test('getAllPublishedComments', () => {
|
|
let publishedComments = element._changeComments
|
|
.getAllPublishedComments();
|
|
assert.equal(Object.keys(publishedComments).length, 4);
|
|
assert.equal(Object.keys(publishedComments[['file/one']]).length, 4);
|
|
assert.equal(Object.keys(publishedComments[['file/two']]).length, 2);
|
|
publishedComments = element._changeComments
|
|
.getAllPublishedComments(2);
|
|
assert.equal(Object.keys(publishedComments[['file/one']]).length, 4);
|
|
assert.equal(Object.keys(publishedComments[['file/two']]).length, 1);
|
|
});
|
|
|
|
test('getAllComments', () => {
|
|
let comments = element._changeComments.getAllComments();
|
|
assert.equal(Object.keys(comments).length, 4);
|
|
assert.equal(Object.keys(comments[['file/one']]).length, 4);
|
|
assert.equal(Object.keys(comments[['file/two']]).length, 2);
|
|
comments = element._changeComments.getAllComments(false, 2);
|
|
assert.equal(Object.keys(comments).length, 4);
|
|
assert.equal(Object.keys(comments[['file/one']]).length, 4);
|
|
assert.equal(Object.keys(comments[['file/two']]).length, 1);
|
|
// Include drafts
|
|
comments = element._changeComments.getAllComments(true);
|
|
assert.equal(Object.keys(comments).length, 4);
|
|
assert.equal(Object.keys(comments[['file/one']]).length, 6);
|
|
assert.equal(Object.keys(comments[['file/two']]).length, 3);
|
|
comments = element._changeComments.getAllComments(true, 2);
|
|
assert.equal(Object.keys(comments).length, 4);
|
|
assert.equal(Object.keys(comments[['file/one']]).length, 6);
|
|
assert.equal(Object.keys(comments[['file/two']]).length, 1);
|
|
});
|
|
|
|
test('computeAllThreads', () => {
|
|
const expectedThreads = [
|
|
{
|
|
...createCommentThread([{...commentObjs['01'], path: 'file/one'}]),
|
|
}, {
|
|
...createCommentThread([{...commentObjs['03'], path: 'file/one'}]),
|
|
}, {
|
|
...createCommentThread([{...commentObjs['04'], path: 'file/one'},
|
|
{...commentObjs['02'], path: 'file/one'},
|
|
{...commentObjs['13'], path: 'file/one'}]),
|
|
}, {
|
|
...createCommentThread([{...commentObjs['05'], path: 'file/two'}]),
|
|
}, {
|
|
...createCommentThread([{...commentObjs['06'], path: 'file/two'}]),
|
|
}, {
|
|
...createCommentThread([{...commentObjs['07'], path: 'file/three'},
|
|
{...commentObjs['08'], path: 'file/three'}]),
|
|
}, {
|
|
...createCommentThread([{...commentObjs['09'], path: 'file/three'}]
|
|
),
|
|
}, {
|
|
...createCommentThread([{...commentObjs['10'], path: 'file/four'}]),
|
|
}, {
|
|
...createCommentThread([{...commentObjs['11'], path: 'file/four'}]),
|
|
}, {
|
|
...createCommentThread([{...commentObjs['12'], path: 'file/one'}]),
|
|
}, {
|
|
...createCommentThread([{...commentObjs['14'], path: 'file/two'}]),
|
|
},
|
|
];
|
|
const threads = element._changeComments.getAllThreadsForChange();
|
|
assert.deepEqual(threads, expectedThreads);
|
|
});
|
|
|
|
test('getCommentsForThreadGroup', () => {
|
|
let expectedComments = [
|
|
{...commentObjs['04'], path: 'file/one'},
|
|
{...commentObjs['02'], path: 'file/one'},
|
|
{...commentObjs['13'], path: 'file/one'},
|
|
];
|
|
assert.deepEqual(element._changeComments.getCommentsForThread('04'),
|
|
expectedComments);
|
|
|
|
expectedComments = [{...commentObjs['12'], path: 'file/one'}];
|
|
|
|
assert.deepEqual(element._changeComments.getCommentsForThread('12'),
|
|
expectedComments);
|
|
|
|
assert.deepEqual(element._changeComments.getCommentsForThread('1000'),
|
|
null);
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|